100个Java经典例子（21-30）初学者的利器高手的宝典JavaSE，21-30javase

来源： javaer 分享于 2019-09-18 点击 27935 次点评：184

100个Java经典例子（21-30）初学者的利器高手的宝典JavaSE，21-30javase

view plainprint?

package test21;
import javax.swing.JDesktopPane;
import javax.swing.JMenu;
import javax.swing.JMenuItem;
import javax.swing.JMenuBar;
import javax.swing.JFrame;
import javax.swing.KeyStroke;
import java.awt.event.*;
import java.awt.*;
/**
* Title: 内部窗体演示
* Description: 这是演示一个内部窗体。可以选择“新文档”菜单不停的生成内部窗体。
* Filename:
*/
public class InternalFrameDemo extends JFrame
implements ActionListener {
private static final long serialVersionUID = 1L;
JDesktopPane desktop;
/**
*方法说明：构造器，添加窗体成员
*输入参数：
*返回类型：
*/
public InternalFrameDemo() {
super("InternalFrameDemo");
//这里设置了一个比较大的窗体，给四周只留了50px的边界
int inset = 50;
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
setBounds(inset, inset,
screenSize.width - inset*2,
screenSize.height - inset*2);
//定义界面
desktop = new JDesktopPane(); //桌面面板
createFrame(); //创建第一个内部窗体
setContentPane(desktop);//将桌面添加到窗体
setJMenuBar(createMenuBar());
//设置托拽模式
desktop.setDragMode(JDesktopPane.OUTLINE_DRAG_MODE);
}
/**
*方法说明：组建菜单
*输入参数：
*返回类型：
*/
protected JMenuBar createMenuBar() {
JMenuBar menuBar = new JMenuBar();
//定义一个菜单
JMenu menu = new JMenu("文件");
menu.setMnemonic(KeyEvent.VK_D);
menuBar.add(menu);
//定义“新文档”菜单
JMenuItem menuItem = new JMenuItem("新文档");
menuItem.setMnemonic(KeyEvent.VK_N);
menuItem.setAccelerator(KeyStroke.getKeyStroke(
KeyEvent.VK_N, ActionEvent.ALT_MASK));
menuItem.setActionCommand("new");
menuItem.addActionListener(this);
menu.add(menuItem);
//定义“退出”菜单
menuItem = new JMenuItem("退出");
menuItem.setMnemonic(KeyEvent.VK_Q);
menuItem.setAccelerator(KeyStroke.getKeyStroke(
KeyEvent.VK_Q, ActionEvent.ALT_MASK));
menuItem.setActionCommand("quit");
menuItem.addActionListener(this);
menu.add(menuItem);
return menuBar;
}
/**
*方法说明：事件监听，对选择的菜单做出反映
*输入参数：ActionEvent e 事件
*返回类型：
*/
public void actionPerformed(ActionEvent e) {
if ("new".equals(e.getActionCommand())) { //新文档
createFrame();
} else { //退出
quit();
}
}
/**
*方法说明：调用MyInternalFrame类创建新的内部窗体，
*输入参数：
*返回类型：
*/
protected void createFrame() {
MyInternalFrame frame = new MyInternalFrame();
frame.setVisible(true);
desktop.add(frame);
try {
frame.setSelected(true);
} catch (java.beans.PropertyVetoException e) {}
}
/**
*方法说明：退出程序
*输入参数：
*返回类型：
*/
protected void quit() {
System.exit(0);
}
/**
*方法说明：主方法
*输入参数：
*返回类型：
*/
public static void main(String[] args) {
JFrame.setDefaultLookAndFeelDecorated(true);
//建立一个内部窗体
InternalFrameDemo frame = new InternalFrameDemo();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//显示窗体
frame.setVisible(true);
}
}

package test21;

import javax.swing.JDesktopPane;
import javax.swing.JMenu;
import javax.swing.JMenuItem;
import javax.swing.JMenuBar;
import javax.swing.JFrame;
import javax.swing.KeyStroke;

import java.awt.event.*;
import java.awt.*;
/**
 * Title: 内部窗体演示
 * Description: 这是演示一个内部窗体。可以选择“新文档”菜单不停的生成内部窗体。
 * Filename: 
 */
public class InternalFrameDemo extends JFrame
                               implements ActionListener {
  
	private static final long serialVersionUID = 1L;
	JDesktopPane desktop;
/**
 *方法说明：构造器，添加窗体成员
 *输入参数：
 *返回类型：
 */
    public InternalFrameDemo() {
        super("InternalFrameDemo");

        //这里设置了一个比较大的窗体，给四周只留了50px的边界
        int inset = 50;
        Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
        setBounds(inset, inset,
                  screenSize.width  - inset*2,
                  screenSize.height - inset*2);
        
        //定义界面
        desktop = new JDesktopPane(); //桌面面板
        createFrame(); //创建第一个内部窗体
        setContentPane(desktop);//将桌面添加到窗体
        setJMenuBar(createMenuBar());

        //设置托拽模式
        desktop.setDragMode(JDesktopPane.OUTLINE_DRAG_MODE);
    }
/**
 *方法说明：组建菜单
 *输入参数：
 *返回类型：
 */
    protected JMenuBar createMenuBar() {
        JMenuBar menuBar = new JMenuBar();

        //定义一个菜单
        JMenu menu = new JMenu("文件");
        menu.setMnemonic(KeyEvent.VK_D);
        menuBar.add(menu);

        //定义“新文档”菜单
        JMenuItem menuItem = new JMenuItem("新文档");
        menuItem.setMnemonic(KeyEvent.VK_N);
        menuItem.setAccelerator(KeyStroke.getKeyStroke(
                KeyEvent.VK_N, ActionEvent.ALT_MASK));
        menuItem.setActionCommand("new");
        menuItem.addActionListener(this);
        menu.add(menuItem);

        //定义“退出”菜单
        menuItem = new JMenuItem("退出");
        menuItem.setMnemonic(KeyEvent.VK_Q);
        menuItem.setAccelerator(KeyStroke.getKeyStroke(
                KeyEvent.VK_Q, ActionEvent.ALT_MASK));
        menuItem.setActionCommand("quit");
        menuItem.addActionListener(this);
        menu.add(menuItem);

        return menuBar;
    }
/**
 *方法说明：事件监听，对选择的菜单做出反映
 *输入参数：ActionEvent e 事件
 *返回类型：
 */
    public void actionPerformed(ActionEvent e) {
        if ("new".equals(e.getActionCommand())) { //新文档
            createFrame();
        } else { //退出
            quit();
        }
    }
/**
 *方法说明：调用MyInternalFrame类创建新的内部窗体，
 *输入参数：
 *返回类型：
 */
    protected void createFrame() {
        MyInternalFrame frame = new MyInternalFrame();
        
        frame.setVisible(true); 
        desktop.add(frame);
        try {
            frame.setSelected(true);
        } catch (java.beans.PropertyVetoException e) {}
    }
/**
 *方法说明：退出程序
 *输入参数：
 *返回类型：
 */
    protected void quit() {
        System.exit(0);
    }
/**
 *方法说明：主方法
 *输入参数：
 *返回类型：
 */
    public static void main(String[] args) {
        JFrame.setDefaultLookAndFeelDecorated(true);

        //建立一个内部窗体
        InternalFrameDemo frame = new InternalFrameDemo();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

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

view plainprint?

package test21;
import javax.swing.JInternalFrame;
import javax.swing.JTextArea;
/**
* Title: 内部窗体
* Description: 生成一个内部窗体，提供InternalFrameDemo类使用
* Filename: MyInternalFrame.java
*/
public class MyInternalFrame extends JInternalFrame {
private static final long serialVersionUID = 1L;
static int openFrameCount = 0;
static final int xOffset = 30, yOffset = 30;
public MyInternalFrame() {
super("文档 #" + (++openFrameCount),
true, //可变尺寸
true, //有关闭按钮
true, //有最大化按钮
true);//最小化按钮
//给内部窗体添加一个文本域
JTextArea j = new JTextArea(5,20);
getContentPane().add(j);
//设置内部窗体的大小
setSize(300,300);
//设置内部窗体的显示位置
setLocation(xOffset*openFrameCount, yOffset*openFrameCount);
}
}

package test21;

import javax.swing.JInternalFrame;
import javax.swing.JTextArea;

/**
 * Title: 内部窗体
 * Description: 生成一个内部窗体，提供InternalFrameDemo类使用
 * Filename: MyInternalFrame.java
 */
public class MyInternalFrame extends JInternalFrame {
  
	private static final long serialVersionUID = 1L;
	static int openFrameCount = 0;
    static final int xOffset = 30, yOffset = 30;

    public MyInternalFrame() {
        super("文档 #" + (++openFrameCount), 
              true, //可变尺寸
              true, //有关闭按钮
              true, //有最大化按钮
              true);//最小化按钮

        //给内部窗体添加一个文本域
        JTextArea j = new JTextArea(5,20);
        getContentPane().add(j);
        //设置内部窗体的大小
        setSize(300,300);

        //设置内部窗体的显示位置
        setLocation(xOffset*openFrameCount, yOffset*openFrameCount);
    }
}

view plainprint?

package test22;
import java.awt.*;
import javax.swing.*;
import javax.swing.event.*;
/**
* Title: 分割面板
* Description: 演示将面板分割成左右两部分
* Fiename:SplitPaneDemo.java
*/
public class SplitPaneDemo implements ListSelectionListener {
private String[] imageNames={"Bird.gif","Cat.gif","Dog.gif","Pig.gif"};
private JLabel picture;
private JList list;
private JSplitPane splitPane;
/**
*方法说明：构造器，定义了所有要使用的构件
*输入参数：
*返回类型：
*/
public SplitPaneDemo() {
//创建一个图像名称的列表，设置为单选方式
list = new JList(imageNames);
list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
list.setSelectedIndex(0);
list.addListSelectionListener(this);
JScrollPane listScrollPane = new JScrollPane(list);
//获取默认的图片
ImageIcon firstImage = createImageIcon("images/" +
(String)imageNames[0]);
if (firstImage != null) {
picture = new JLabel(firstImage);
picture.setPreferredSize(new Dimension(firstImage.getIconWidth(),
firstImage.getIconHeight()));
} else {
picture = new JLabel((String)imageNames[0]);
}
JScrollPane pictureScrollPane = new JScrollPane(picture);
//创建一个水平分割的面板，定义了两个面板的名字。
splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT,true,
listScrollPane, pictureScrollPane);
splitPane.setOneTouchExpandable(true);
splitPane.setDividerLocation(150);
//定义面板的最小尺寸
Dimension minimumSize = new Dimension(100, 50);
listScrollPane.setMinimumSize(minimumSize);
pictureScrollPane.setMinimumSize(minimumSize);
//定义初始尺寸
splitPane.setPreferredSize(new Dimension(400, 200));
}
/**
*方法说明：获得这个分割的面板
*输入参数：
*返回类型：JSplitPane 对象
*/
public JSplitPane getSplitPane() {
return splitPane;
}
/**
*方法说明：列表监听事件处理
*输入参数：ListSelectionEvent e 列表选择事件
*返回类型：
*/
public void valueChanged(ListSelectionEvent e) {
if (e.getValueIsAdjusting())
return;
JList theList = (JList)e.getSource();
if (theList.isSelectionEmpty()) {
picture.setIcon(null);
picture.setText(null);
} else {
int index = theList.getSelectedIndex();
ImageIcon newImage = createImageIcon("images/" +
(String)imageNames[index]);
picture.setIcon(newImage);
if (newImage != null) {
picture.setText(null);
picture.setPreferredSize(new Dimension(newImage.getIconWidth(),
newImage.getIconHeight() ));
} else {
picture.setText("Image not found: "
+ (String)imageNames[index]);
}
picture.revalidate();
}
}
/**
*方法说明：根据路径获取图形对象
*输入参数：String path 图片路径
*返回类型：ImageIcon 图片对象
*/
protected static ImageIcon createImageIcon(String path) {
java.net.URL imgURL = SplitPaneDemo.class.getResource(path);
if (imgURL != null) {
return new ImageIcon(imgURL);
} else {
System.err.println("Couldn't find file: " + path);
return null;
}
}
/**
*方法说明：主方法
*输入参数：
*返回类型：
*/
public static void main(String[] args) {
JFrame.setDefaultLookAndFeelDecorated(true);
//定义窗体
JFrame frame = new JFrame("SplitPaneDemo");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
SplitPaneDemo splitPaneDemo = new SplitPaneDemo();
frame.getContentPane().add(splitPaneDemo.getSplitPane());
//显示窗体
frame.pack();
frame.setVisible(true);
}
}

package test22;

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

/**
 * Title: 分割面板
 * Description: 演示将面板分割成左右两部分
 * Fiename:SplitPaneDemo.java 
 */
public class SplitPaneDemo implements ListSelectionListener {
    private String[] imageNames={"Bird.gif","Cat.gif","Dog.gif","Pig.gif"};
    private JLabel picture;
    private JList list;
    private JSplitPane splitPane;
/**
 *方法说明：构造器，定义了所有要使用的构件
 *输入参数：
 *返回类型：
 */
    public SplitPaneDemo() {
        
        //创建一个图像名称的列表，设置为单选方式
        list = new JList(imageNames);
        list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
        list.setSelectedIndex(0);
        list.addListSelectionListener(this);
        JScrollPane listScrollPane = new JScrollPane(list);

        //获取默认的图片
        ImageIcon firstImage = createImageIcon("images/" +
                                     (String)imageNames[0]);
        if (firstImage != null) {
            picture = new JLabel(firstImage);
            picture.setPreferredSize(new Dimension(firstImage.getIconWidth(),
                                                   firstImage.getIconHeight()));
        } else {
            picture = new JLabel((String)imageNames[0]);
        }
        JScrollPane pictureScrollPane = new JScrollPane(picture);

        //创建一个水平分割的面板，定义了两个面板的名字。
        splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT,true,
                                   listScrollPane, pictureScrollPane);
        splitPane.setOneTouchExpandable(true);
        splitPane.setDividerLocation(150);

        //定义面板的最小尺寸
        Dimension minimumSize = new Dimension(100, 50);
        listScrollPane.setMinimumSize(minimumSize);
        pictureScrollPane.setMinimumSize(minimumSize);

        //定义初始尺寸
        splitPane.setPreferredSize(new Dimension(400, 200));
    }
/**
 *方法说明：获得这个分割的面板
 *输入参数：
 *返回类型：JSplitPane 对象
 */
    public JSplitPane getSplitPane() {
        return splitPane;
    }
/**
 *方法说明：列表监听事件处理
 *输入参数：ListSelectionEvent e 列表选择事件
 *返回类型：
 */
    public void valueChanged(ListSelectionEvent e) {
        if (e.getValueIsAdjusting())
            return;

        JList theList = (JList)e.getSource();
        if (theList.isSelectionEmpty()) {
            picture.setIcon(null);
            picture.setText(null);
        } else {
            int index = theList.getSelectedIndex();
            ImageIcon newImage = createImageIcon("images/" +
                                     (String)imageNames[index]);
            picture.setIcon(newImage);
            if (newImage != null) {
                picture.setText(null);
                picture.setPreferredSize(new Dimension(newImage.getIconWidth(),
                                                       newImage.getIconHeight() ));
            } else {
                picture.setText("Image not found: "
                                + (String)imageNames[index]);
            }
            picture.revalidate();
        }
    }
/**
 *方法说明：根据路径获取图形对象
 *输入参数：String path 图片路径
 *返回类型：ImageIcon 图片对象
 */
    protected static ImageIcon createImageIcon(String path) {
        java.net.URL imgURL = SplitPaneDemo.class.getResource(path);
        if (imgURL != null) {
            return new ImageIcon(imgURL);
        } else {
            System.err.println("Couldn't find file: " + path);
            return null;
        }
    }
/**
 *方法说明：主方法
 *输入参数：
 *返回类型：
 */
    public static void main(String[] args) {
        JFrame.setDefaultLookAndFeelDecorated(true);

        //定义窗体
        JFrame frame = new JFrame("SplitPaneDemo");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        SplitPaneDemo splitPaneDemo = new SplitPaneDemo();
        frame.getContentPane().add(splitPaneDemo.getSplitPane());

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

view plainprint?

package test23;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
/**
* Title: 滑动杆演示
* Description: 使用滑动杆控制定时器，来控制图片的播放速度
* Filename: SliderDemo.java
*/
public class SliderDemo extends JPanel
implements ActionListener,
WindowListener,
ChangeListener {
private static final long serialVersionUID = 1L;
//设置图片的参数
static final int FPS_MIN = 0; //设置最小值
static final int FPS_MAX = 30; //设置最大值
static final int FPS_INIT = 15; //初始数值
int frameNumber = 0;
int NUM_FRAMES = 14;
ImageIcon[] images = new ImageIcon[NUM_FRAMES];
int delay;
Timer timer;
boolean frozen = false;
//这个标签用来显示这只小狗
JLabel picture;
public SliderDemo() {
setLayout(new BoxLayout(this, BoxLayout.PAGE_AXIS));
delay = 1000 / FPS_INIT;
//信息提示标签
JLabel sliderLabel = new JLabel("调整滑动杆，改变播放速度！", JLabel.CENTER);
sliderLabel.setAlignmentX(Component.CENTER_ALIGNMENT);
//创建一个滑动杆，定义了最小值和最大值以及初始值
JSlider framesPerSecond = new JSlider(JSlider.HORIZONTAL,
FPS_MIN, FPS_MAX, FPS_INIT);
framesPerSecond.addChangeListener(this);
//定义滑动杆参数
framesPerSecond.setMajorTickSpacing(10);//每10刻度标注一次
framesPerSecond.setMinorTickSpacing(1);//最小刻度为1
framesPerSecond.setPaintTicks(true);//绘制滑动杆上的刻度
framesPerSecond.setPaintLabels(true);//在滑动过程中绘制滑动块
framesPerSecond.setBorder(
BorderFactory.createEmptyBorder(0,0,10,0));
//定义一个用来显示图片的标签
picture = new JLabel();
picture.setHorizontalAlignment(JLabel.CENTER);
picture.setAlignmentX(Component.CENTER_ALIGNMENT);
picture.setBorder(BorderFactory.createCompoundBorder(
BorderFactory.createLoweredBevelBorder(),
BorderFactory.createEmptyBorder(10,10,10,10)));
updatePicture(0); //显示第一张图
//将成员添加到面板上
add(sliderLabel);
add(framesPerSecond);
add(picture);
setBorder(BorderFactory.createEmptyBorder(10,10,10,10));
//设置一个定时器来触发这个事件
timer = new Timer(delay, this);
timer.setInitialDelay(delay * 7); //在每轮循环停顿时间
timer.setCoalesce(true);//设置重复循环
}
/**
*方法说明：添加一个窗体监听
*输入参数：
*返回类型：
*/
void addWindowListener(Window w) {
w.addWindowListener(this);
}
public void windowIconified(WindowEvent e) {
stopAnimation();
}
public void windowDeiconified(WindowEvent e) {
startAnimation();
}
public void windowOpened(WindowEvent e) {}
public void windowClosing(WindowEvent e) {}
public void windowClosed(WindowEvent e) {}
public void windowActivated(WindowEvent e) {}
public void windowDeactivated(WindowEvent e) {}
/**
*方法说明：对滑动杆进行监听
*输入参数：ChangeEvent e 滑动杆变动事件
*返回类型：
*/
public void stateChanged(ChangeEvent e) {
JSlider source = (JSlider)e.getSource();
if (!source.getValueIsAdjusting()) {
int fps = (int)source.getValue();//获得滑动杆的值
if (fps == 0) {
if (!frozen) stopAnimation();
} else {
delay = 1000 / fps;
timer.setDelay(delay);
timer.setInitialDelay(delay * 10);
if (frozen) startAnimation();
}
}
}
/**
*方法说明：开始动画
*输入参数：
*返回类型：
*/
public void startAnimation() {
timer.start();
frozen = false;
}
/**
*方法说明：停止动画
*输入参数：
*返回类型：
*/
public void stopAnimation() {
timer.stop();
frozen = true;
}
/**
*方法说明：事件监听
*输入参数：
*返回类型：
*/
public void actionPerformed(ActionEvent e) {
//改变图片帧
if (frameNumber == (NUM_FRAMES - 1)) {
frameNumber = 0;
} else {
frameNumber++;
}
updatePicture(frameNumber); //显示下张图
if ( frameNumber==(NUM_FRAMES - 1)
|| frameNumber==(NUM_FRAMES/2 - 1) ) {
timer.restart();
}
}
/**
*方法说明：绘制当前帧
*输入参数：int frameNum 图片帧数数
*返回类型：
*/
protected void updatePicture(int frameNum) {
if (images[frameNumber] == null) {
images[frameNumber] = createImageIcon("images/doggy/T"
+ frameNumber
+ ".gif");
}
//绘制图片
if (images[frameNumber] != null) {
picture.setIcon(images[frameNumber]);
} else { //如果没有发现图片
picture.setText("image #" + frameNumber + " not found");
}
}
/**
*方法说明：获取图片
*输入参数：String path 图片路径
*返回类型：ImageIcon 图片对象
*/
protected static ImageIcon createImageIcon(String path) {
java.net.URL imgURL = SliderDemo.class.getResource(path);
if (imgURL != null) {
return new ImageIcon(imgURL);
} else {
System.err.println("Couldn't find file: " + path);
return null;
}
}
/**
*方法说明：主方法
*输入参数：
*返回类型：
*/
public static void main(String[] args) {
JFrame.setDefaultLookAndFeelDecorated(true);
//定义窗体
JFrame frame = new JFrame("SliderDemo");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//实例化本类
SliderDemo animator = new SliderDemo();
animator.setOpaque(true);
frame.setContentPane(animator);
//显示窗体
frame.pack();
frame.setVisible(true);
animator.startAnimation();
}
}

package test23;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
/**
 * Title: 滑动杆演示
 * Description: 使用滑动杆控制定时器，来控制图片的播放速度
 * Filename: SliderDemo.java
 */
public class SliderDemo extends JPanel
                        implements ActionListener,
                                   WindowListener,
                                   ChangeListener {

	private static final long serialVersionUID = 1L;
	//设置图片的参数
    static final int FPS_MIN = 0; //设置最小值
    static final int FPS_MAX = 30; //设置最大值
    static final int FPS_INIT = 15;  //初始数值
    int frameNumber = 0;
    int NUM_FRAMES = 14;
    ImageIcon[] images = new ImageIcon[NUM_FRAMES];
    int delay;
    Timer timer;
    boolean frozen = false;

    //这个标签用来显示这只小狗
    JLabel picture;

    public SliderDemo() {
        setLayout(new BoxLayout(this, BoxLayout.PAGE_AXIS));

        delay = 1000 / FPS_INIT;

        //信息提示标签
        JLabel sliderLabel = new JLabel("调整滑动杆，改变播放速度！", JLabel.CENTER);
        sliderLabel.setAlignmentX(Component.CENTER_ALIGNMENT);

        //创建一个滑动杆，定义了最小值和最大值以及初始值
        JSlider framesPerSecond = new JSlider(JSlider.HORIZONTAL,
                                              FPS_MIN, FPS_MAX, FPS_INIT);
        framesPerSecond.addChangeListener(this);

        //定义滑动杆参数
        framesPerSecond.setMajorTickSpacing(10);//每10刻度标注一次
        framesPerSecond.setMinorTickSpacing(1);//最小刻度为1
        framesPerSecond.setPaintTicks(true);//绘制滑动杆上的刻度
        framesPerSecond.setPaintLabels(true);//在滑动过程中绘制滑动块
        framesPerSecond.setBorder(
                BorderFactory.createEmptyBorder(0,0,10,0));

        //定义一个用来显示图片的标签
        picture = new JLabel();
        picture.setHorizontalAlignment(JLabel.CENTER);
        picture.setAlignmentX(Component.CENTER_ALIGNMENT);
        picture.setBorder(BorderFactory.createCompoundBorder(
                BorderFactory.createLoweredBevelBorder(),
                BorderFactory.createEmptyBorder(10,10,10,10)));
        updatePicture(0); //显示第一张图

        //将成员添加到面板上
        add(sliderLabel);
        add(framesPerSecond);
        add(picture);
        setBorder(BorderFactory.createEmptyBorder(10,10,10,10));

        //设置一个定时器来触发这个事件
        timer = new Timer(delay, this);
        timer.setInitialDelay(delay * 7); //在每轮循环停顿时间
        timer.setCoalesce(true);//设置重复循环
    }
/**
 *方法说明：添加一个窗体监听
 *输入参数：
 *返回类型：
 */
    void addWindowListener(Window w) {
        w.addWindowListener(this);
    }
    public void windowIconified(WindowEvent e) {
        stopAnimation();
    }
    public void windowDeiconified(WindowEvent e) {
        startAnimation();
    }
    public void windowOpened(WindowEvent e) {}
    public void windowClosing(WindowEvent e) {}
    public void windowClosed(WindowEvent e) {}
    public void windowActivated(WindowEvent e) {}
    public void windowDeactivated(WindowEvent e) {}
/**
 *方法说明：对滑动杆进行监听
 *输入参数：ChangeEvent e 滑动杆变动事件
 *返回类型：
 */
    public void stateChanged(ChangeEvent e) {
        JSlider source = (JSlider)e.getSource();
        if (!source.getValueIsAdjusting()) {
            int fps = (int)source.getValue();//获得滑动杆的值
            if (fps == 0) {
                if (!frozen) stopAnimation();
            } else {
                delay = 1000 / fps;
                timer.setDelay(delay);
                timer.setInitialDelay(delay * 10);
                if (frozen) startAnimation();
            }
        }
    }
/**
 *方法说明：开始动画
 *输入参数：
 *返回类型：
 */
    public void startAnimation() {
        timer.start();
        frozen = false;
    }
/**
 *方法说明：停止动画
 *输入参数：
 *返回类型：
 */
    public void stopAnimation() {
        timer.stop();
        frozen = true;
    }
/**
 *方法说明：事件监听
 *输入参数：
 *返回类型：
 */
    public void actionPerformed(ActionEvent e) {
        //改变图片帧
        if (frameNumber == (NUM_FRAMES - 1)) {
            frameNumber = 0;
        } else {
            frameNumber++;
        }

        updatePicture(frameNumber); //显示下张图

        if ( frameNumber==(NUM_FRAMES - 1)
          || frameNumber==(NUM_FRAMES/2 - 1) ) {
            timer.restart();
        }
    }
/**
 *方法说明：绘制当前帧
 *输入参数：int frameNum 图片帧数数
 *返回类型：
 */
    protected void updatePicture(int frameNum) {
        if (images[frameNumber] == null) {
            images[frameNumber] = createImageIcon("images/doggy/T"
                                                  + frameNumber
                                                  + ".gif");
        }

        //绘制图片
        if (images[frameNumber] != null) {
            picture.setIcon(images[frameNumber]);
        } else { //如果没有发现图片
            picture.setText("image #" + frameNumber + " not found");
        }
    }
/**
 *方法说明：获取图片
 *输入参数：String path 图片路径
 *返回类型：ImageIcon 图片对象
 */
    protected static ImageIcon createImageIcon(String path) {
        java.net.URL imgURL = SliderDemo.class.getResource(path);
        if (imgURL != null) {
            return new ImageIcon(imgURL);
        } else {
            System.err.println("Couldn't find file: " + path);
            return null;
        }
    }
/**
 *方法说明：主方法
 *输入参数：
 *返回类型：
 */
    public static void main(String[] args) {
        JFrame.setDefaultLookAndFeelDecorated(true);

        //定义窗体
        JFrame frame = new JFrame("SliderDemo");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        //实例化本类
        SliderDemo animator = new SliderDemo();
        animator.setOpaque(true);
        frame.setContentPane(animator);

        //显示窗体
        frame.pack();
        frame.setVisible(true);
        animator.startAnimation(); 
    }
}

view plainprint?

package test24;
import java.awt.*;
import javax.swing.*;
import javax.swing.event.*;
/**
* Title: 颜色选择器
* Description: 演示一个颜色选择器，可以从样本中选择，可以使用HSB模式和RGB模式
* Filename: ColorChooserDemo.java
*/
public class ColorChooserDemo extends JPanel
implements ChangeListener {
private static final long serialVersionUID = 1L;
protected JColorChooser tcc;
protected JLabel banner;
public ColorChooserDemo() {
super(new BorderLayout());
//设置一个标签，做广告的。也用来显示用户选择的颜色。
banner = new JLabel("欢迎使用颜色选择器！",
JLabel.CENTER);
banner.setForeground(Color.yellow);
banner.setBackground(Color.blue);
banner.setOpaque(true);
banner.setFont(new Font("SansSerif", Font.BOLD, 24));
banner.setPreferredSize(new Dimension(100, 65));
JPanel bannerPanel = new JPanel(new BorderLayout());
bannerPanel.add(banner, BorderLayout.CENTER);
bannerPanel.setBorder(BorderFactory.createTitledBorder("广告"));
//设置选择颜色选择器
tcc = new JColorChooser(banner.getForeground());//设置初始颜色
tcc.getSelectionModel().addChangeListener(this);//给所有模式添加监听
tcc.setBorder(BorderFactory.createTitledBorder("选择颜色"));
add(bannerPanel, BorderLayout.CENTER);
add(tcc, BorderLayout.PAGE_END);
}
/**
*方法说明：事件监听。用户选择颜色触发
*输入参数：ChangeEvent e 用户选择事件
*返回类型：
*/
public void stateChanged(ChangeEvent e) {
Color newColor = tcc.getColor();//获取用户选择的颜色
banner.setForeground(newColor);
}
/**
*方法说明：主方法
*输入参数：
*返回类型：
*/
public static void main(String[] args) {
JFrame.setDefaultLookAndFeelDecorated(true);
//创建窗体
JFrame frame = new JFrame("ColorChooserDemo");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//创建面板容器
JComponent newContentPane = new ColorChooserDemo();
newContentPane.setOpaque(true);
frame.setContentPane(newContentPane);
//显示窗体
frame.pack();
frame.setVisible(true);
}
}

package test24;

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

/**
 * Title: 颜色选择器
 * Description: 演示一个颜色选择器，可以从样本中选择，可以使用HSB模式和RGB模式
 * Filename: ColorChooserDemo.java
 */

public class ColorChooserDemo extends JPanel
                              implements ChangeListener {

   
	private static final long serialVersionUID = 1L;
	protected JColorChooser tcc;
    protected JLabel banner;

    public ColorChooserDemo() {
        super(new BorderLayout());

        //设置一个标签，做广告的。也用来显示用户选择的颜色。
        banner = new JLabel("欢迎使用颜色选择器！",
                            JLabel.CENTER);
        banner.setForeground(Color.yellow);
        banner.setBackground(Color.blue);
        banner.setOpaque(true);
        banner.setFont(new Font("SansSerif", Font.BOLD, 24));
        banner.setPreferredSize(new Dimension(100, 65));

        JPanel bannerPanel = new JPanel(new BorderLayout());
        bannerPanel.add(banner, BorderLayout.CENTER);
        bannerPanel.setBorder(BorderFactory.createTitledBorder("广告"));

        //设置选择颜色选择器
        tcc = new JColorChooser(banner.getForeground());//设置初始颜色
        tcc.getSelectionModel().addChangeListener(this);//给所有模式添加监听
        tcc.setBorder(BorderFactory.createTitledBorder("选择颜色"));

        add(bannerPanel, BorderLayout.CENTER);
        add(tcc, BorderLayout.PAGE_END);
    }
/**
 *方法说明：事件监听。用户选择颜色触发
 *输入参数：ChangeEvent e 用户选择事件
 *返回类型：
 */
    public void stateChanged(ChangeEvent e) {
        Color newColor = tcc.getColor();//获取用户选择的颜色
        banner.setForeground(newColor);
    }
/**
 *方法说明：主方法
 *输入参数：
 *返回类型：
 */
    public static void main(String[] args) {
        JFrame.setDefaultLookAndFeelDecorated(true);

        //创建窗体
        JFrame frame = new JFrame("ColorChooserDemo");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        //创建面板容器
        JComponent newContentPane = new ColorChooserDemo();
        newContentPane.setOpaque(true);
        frame.setContentPane(newContentPane);

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

view plainprint?

package test25;
import javax.swing.JTable;
import javax.swing.table.AbstractTableModel;
import javax.swing.JScrollPane;
import javax.swing.JFrame;
import java.awt.*;
import java.awt.event.*;
/**
* Title: 自己定义的表格
* Description: 继承AbstractTableModel类，实现自己的表格
* Flename: MyTableDemo.java
*/
public class MyTableDemo extends JFrame {
private static final long serialVersionUID = 1L;
public MyTableDemo() {
super("MyTableDemo");
//声明自己的表格，并添加到JTable中
MyTableModel myModel = new MyTableModel();
JTable table = new JTable(myModel);
table.setPreferredScrollableViewportSize(new Dimension(500, 70));
//将表格添加到可滚动的面板
JScrollPane scrollPane = new JScrollPane(table);
//将滚动面板添加到窗体
getContentPane().add(scrollPane, BorderLayout.CENTER);
//添加监听
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}
/**
* Title: 定义自己的表格模式
* Description: 通过继承AbstractTableModel类来定义自己的表格模式，
* 这里使得第三个以后才可以编辑
*/
class MyTableModel extends AbstractTableModel {
private static final long serialVersionUID = 1L;
//定义表头
final String[] columnNames = {"姓名",
"性别",
"学历",
"年龄",
"是否已婚"};
//初始化表数据
final Object[][] data = {
{"张三", "男",
"大本", new Integer(25), new Boolean(false)},
{"李四", "男",
"大本", new Integer(33), new Boolean(true)},
{"王五", "男",
"高中", new Integer(20), new Boolean(false)},
{"赵倩", "女",
"大专", new Integer(26), new Boolean(true)},
{"周大", "男",
"大本", new Integer(24), new Boolean(false)}
};
/**
*方法说明：继承AbstractTableModel必须实现的方法
*输入参数：
*返回类型：int 列数
*/
public int getColumnCount() {
return columnNames.length;
}
/**
*方法说明：继承AbstractTableModel必须实现的方法
*输入参数：
*返回类型：int 列数
*/
public int getRowCount() {
return data.length;
}
/**
*方法说明：继承AbstractTableModel必须实现的方法
*输入参数：
*返回类型：String 列名
*/
public String getColumnName(int col) {
return columnNames[col];
}
/**
*方法说明：继承AbstractTableModel必须实现的方法，获取表格中的数据
*输入参数：int row 行数
*输入参数：int col 列数
*返回类型：Object 数据对象
*/
public Object getValueAt(int row, int col) {
return data[row][col];
}
/**
*方法说明：实现这个方法使得最后一列不是显示true和false。而是使用检查盒
*输入参数：
*返回类型：
*/
@SuppressWarnings("unchecked")
public Class getColumnClass(int c) {
return getValueAt(0, c).getClass();
}
/**
*方法说明：这个方法不一定需要实现。这里是为了定义可编辑的列
*输入参数：
*返回类型：boolean 是否可编辑
*/
public boolean isCellEditable(int row, int col) {
if (col < 2) {
return false;
} else {
return true;
}
}
/**
*方法说明：实现此方法，获得编辑数据。
*输入参数：
*返回类型：
*/
public void setValueAt(Object value, int row, int col) {
System.out.println("修改数据位置： " + row + "," + col
+ " 新数据为： " + value);
data[row][col] = value;
fireTableCellUpdated(row, col);
System.out.println("表格新数据:");
printDebugData();
}
/**
*方法说明：输出表格中的新数据
*输入参数：
*返回类型：
*/
private void printDebugData() {
int numRows = getRowCount();
int numCols = getColumnCount();
for (int i=0; i < numRows; i++) {
System.out.print(" 行 " + i + ":");
for (int j=0; j < numCols; j++) {
System.out.print(" " + data[i][j]);
}
System.out.println();
}
System.out.println("--------------------------");
}
}
/**
*方法说明：主方法
*输入参数：
*返回类型：
*/
public static void main(String[] args) {
JFrame.setDefaultLookAndFeelDecorated(true);
MyTableDemo frame = new MyTableDemo();
frame.pack();
frame.setVisible(true);
}
}

package test25;

import javax.swing.JTable;
import javax.swing.table.AbstractTableModel;

import javax.swing.JScrollPane;
import javax.swing.JFrame;
import java.awt.*;
import java.awt.event.*;
/**
 * Title: 自己定义的表格
 * Description: 继承AbstractTableModel类，实现自己的表格
 * Flename: MyTableDemo.java
 */
public class MyTableDemo extends JFrame {

  
	private static final long serialVersionUID = 1L;
	public MyTableDemo() {
        super("MyTableDemo");
        //声明自己的表格，并添加到JTable中
        MyTableModel myModel = new MyTableModel();
        JTable table = new JTable(myModel);
        table.setPreferredScrollableViewportSize(new Dimension(500, 70));

        //将表格添加到可滚动的面板
        JScrollPane scrollPane = new JScrollPane(table);

        //将滚动面板添加到窗体
        getContentPane().add(scrollPane, BorderLayout.CENTER);
        //添加监听
        addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
    }
/**
 * Title: 定义自己的表格模式
 * Description: 通过继承AbstractTableModel类来定义自己的表格模式，
 *    这里使得第三个以后才可以编辑
 */
    class MyTableModel extends AbstractTableModel {
    
	private static final long serialVersionUID = 1L;
		//定义表头
        final String[] columnNames = {"姓名", 
                                      "性别",
                                      "学历",
                                      "年龄",
                                      "是否已婚"};
        //初始化表数据
        final Object[][] data = {
            {"张三", "男", 
             "大本", new Integer(25), new Boolean(false)},
            {"李四", "男", 
             "大本", new Integer(33), new Boolean(true)},
            {"王五", "男",
             "高中", new Integer(20), new Boolean(false)},
            {"赵倩", "女",
             "大专", new Integer(26), new Boolean(true)},
            {"周大", "男",
             "大本", new Integer(24), new Boolean(false)}
        };
/**
 *方法说明：继承AbstractTableModel必须实现的方法
 *输入参数：
 *返回类型：int 列数
 */
        public int getColumnCount() {
            return columnNames.length;
        }
/**
 *方法说明：继承AbstractTableModel必须实现的方法
 *输入参数：
 *返回类型：int 列数
 */        
        public int getRowCount() {
            return data.length;
        }
/**
 *方法说明：继承AbstractTableModel必须实现的方法
 *输入参数：
 *返回类型：String 列名
 */
        public String getColumnName(int col) {
            return columnNames[col];
        }
/**
 *方法说明：继承AbstractTableModel必须实现的方法，获取表格中的数据
 *输入参数：int row 行数
 *输入参数：int col 列数
 *返回类型：Object 数据对象
 */
        public Object getValueAt(int row, int col) {
            return data[row][col];
        }
/**
 *方法说明：实现这个方法使得最后一列不是显示true和false。而是使用检查盒
 *输入参数：
 *返回类型：
 */
        @SuppressWarnings("unchecked")
		public Class getColumnClass(int c) {
            return getValueAt(0, c).getClass();
        }
/**
 *方法说明：这个方法不一定需要实现。这里是为了定义可编辑的列
 *输入参数：
 *返回类型：boolean 是否可编辑
 */
        public boolean isCellEditable(int row, int col) {
            if (col < 2) { 
                return false;
            } else {
                return true;
            }
        }
/**
 *方法说明：实现此方法，获得编辑数据。
 *输入参数：
 *返回类型：
 */
        public void setValueAt(Object value, int row, int col) {
                System.out.println("修改数据位置： " + row + "," + col
                                   + " 新数据为： " + value);

            data[row][col] = value;
            fireTableCellUpdated(row, col);

                System.out.println("表格新数据:");
                printDebugData();

        }
/**
 *方法说明：输出表格中的新数据
 *输入参数：
 *返回类型：
 */
        private void printDebugData() {
            int numRows = getRowCount();
            int numCols = getColumnCount();

            for (int i=0; i < numRows; i++) {
                System.out.print("    行 " + i + ":");
                for (int j=0; j < numCols; j++) {
                    System.out.print("  " + data[i][j]);
                }
                System.out.println();
            }
            System.out.println("--------------------------");
        }
    }
/**
 *方法说明：主方法
 *输入参数：
 *返回类型：
 */
    public static void main(String[] args) {
    	JFrame.setDefaultLookAndFeelDecorated(true);
        MyTableDemo frame = new MyTableDemo();
        frame.pack();
        frame.setVisible(true);
    }
}

view plainprint?

package test26;
import java.awt.*;
import javax.swing.*;
/**
* Title: 基本图形的绘制
* Description: 本实例演示绘制四边型、圆角矩形、椭圆等基本的图形。
* Filename: Sample.java
*/
public class Sample extends JFrame {
private static final long serialVersionUID = 1L;
/**
*方法说明：主方法
*输入参数：
*返回类型：
*/
public static void main(String[] args){
Sample sl = new Sample();
sl.update();
}
/**
*方法说明：构造器，显示窗体
*输入参数：
*返回类型：
*/
@SuppressWarnings("deprecation")
Sample(){
super("Sample");
setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
setSize(310,160);
show();
}
/**
*方法说明：更新画面
*输入参数：
*返回类型：
*/
public void update(){
repaint();
}
/**
*方法说明：绘制画面
*输入参数：
*返回类型：
*/
public void paint(Graphics g) {
int [] x={10,30,80,50,10};
int [] y={90,140,120,100,90};
g.setColor(Color.cyan);
//绘制竖格线
for (int i=0; i<=300; i+=10) {
g.drawLine(i,0,i,150);
}
//绘制横格线
for (int i=0; i<=150; i+=10) {
g.drawLine(0,i,300,i);
}
g.setColor(Color.black);
//有角矩形，起始点(10,30)，宽80，高50
g.drawRect(10,30,80,50);
//圆角矩形，起始点(110,30)，宽80，高50，角（a=20,b=10）
g.drawRoundRect(110,30,80,50,20,10);
//多角边
g.drawPolygon(x,y,5);
//椭圆，圆心（110,90）、a=80,b=50
g.drawOval(110,90,80,50);
//一条弧，圆心（219,30）、a=80,b=50 角度在0-90之间
g.drawArc(210,30,80,50,0,90);
//扇面，圆心（219,90）、a=80,b=50 角度在0-90之间
g.fillArc(210,90,80,50,0,90);
}
}

package test26;

import java.awt.*; 
import javax.swing.*;
/**
 * Title: 基本图形的绘制
 * Description: 本实例演示绘制四边型、圆角矩形、椭圆等基本的图形。 
 * Filename: Sample.java
 */
public class Sample extends JFrame { 

	private static final long serialVersionUID = 1L;
/**
 *方法说明：主方法
 *输入参数：
 *返回类型：
 */  
  public static void main(String[] args){
    Sample sl = new Sample();
    sl.update();
  }
/**
 *方法说明：构造器，显示窗体
 *输入参数：
 *返回类型：
 */  
  @SuppressWarnings("deprecation")
Sample(){
    super("Sample");
    setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
    setSize(310,160);
    show();
  }
/**
 *方法说明：更新画面
 *输入参数：
 *返回类型：
 */  
  public void update(){
    repaint();
  }
/**
 *方法说明：绘制画面
 *输入参数：
 *返回类型：
 */  
  public void paint(Graphics g) { 
     int [] x={10,30,80,50,10};
     int [] y={90,140,120,100,90};
     g.setColor(Color.cyan);      
     //绘制竖格线
     for (int i=0; i<=300; i+=10) { 
        g.drawLine(i,0,i,150);    
     }
     //绘制横格线 
     for (int i=0; i<=150; i+=10) { 
        g.drawLine(0,i,300,i);    
     }
     g.setColor(Color.black);     
     //有角矩形，起始点(10,30)，宽80，高50
     g.drawRect(10,30,80,50);     
     //圆角矩形，起始点(110,30)，宽80，高50，角（a=20,b=10）
     g.drawRoundRect(110,30,80,50,20,10);
     //多角边
     g.drawPolygon(x,y,5);
     //椭圆，圆心（110,90）、a=80,b=50       
     g.drawOval(110,90,80,50); 
     //一条弧，圆心（219,30）、a=80,b=50 角度在0-90之间
     g.drawArc(210,30,80,50,0,90);
     //扇面，圆心（219,90）、a=80,b=50 角度在0-90之间
     g.fillArc(210,90,80,50,0,90);
  }
}

view plainprint?

package test27;
import java.awt.*;
import javax.swing.*;
public class Func extends JFrame{
private static final long serialVersionUID = 1L;
/**
*方法说明：主方法
*输入参数：
*返回类型：
*/
public static void main(String[] args){
Func db = new Func();
db.update();
}
/**
*方法说明：构造器，显示窗体
*输入参数：
*返回类型：
*/
@SuppressWarnings("deprecation")
Func(){
super("Function");
setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
setSize(310,310);
show();
}
/**
*方法说明：更新画面
*输入参数：
*返回类型：
*/
public void update(){
repaint();
}
/**
*方法说明：转换坐标点
*输入参数：
*返回类型：
*/
double f(double x) {
return (Math.sin(2*x)+Math.cos(3*x));
}
/**
*方法说明：绘制坐标图
*输入参数：
*返回类型：
*/
public void paint(Graphics g) {
double x0,x1,y0,y1,xd,yd;
double max=5.0;
int w,h,hw,hh;
//获取屏幕的尺寸
w=getSize().width;
h=getSize().height;
hw=w/2; hh=h/2;
//在屏幕上输出字符
g.drawString("Sin[2x]+Cos[3x]",10,40);
g.setColor(Color.red);
g.drawString("0",hw+5,hh+12);
g.drawString(""+max,hw-20,40);
g.drawString(""+max,w-20,hh+12);
//绘制X轴坐标
g.drawLine(0,hh,w,hh);
//绘制Y轴坐标
g.drawLine(hw,0,hw,h);
xd=2*max/w;//计算X增量
yd=hh/max; //计算y增量
g.setColor(Color.blue);
//使用增量绘制一小段线，最终组成曲线图形。
for (int x=0 ; x<w-1; x++) {
x0=-max+x*xd; y0=f(x0)*yd;
x1=x0+xd; y1=f(x1)*yd;
g.drawLine(x,(int)(hh-y0),x+1,(int)(hh-y1));
}
}
} //end

package test27;

 import java.awt.*;
import javax.swing.*; 
 
 public class Func extends JFrame{ 

	private static final long serialVersionUID = 1L;
/**
 *方法说明：主方法
 *输入参数：
 *返回类型：
 */
  public static void main(String[] args){
    Func db = new Func();
    db.update();
  }
/**
 *方法说明：构造器，显示窗体
 *输入参数：
 *返回类型：
 */ 
  @SuppressWarnings("deprecation")
Func(){
    super("Function");
    setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
    setSize(310,310);
    show();
  }
/**
 *方法说明：更新画面
 *输入参数：
 *返回类型：
 */ 
  public void update(){
     repaint();
  }
/**
 *方法说明：转换坐标点
 *输入参数：
 *返回类型：
 */
  double f(double x) {  
       return (Math.sin(2*x)+Math.cos(3*x)); 
  }
/**
 *方法说明：绘制坐标图
 *输入参数：
 *返回类型：
 */  
  public void paint(Graphics g) { 
       double x0,x1,y0,y1,xd,yd; 
       double max=5.0; 
       int w,h,hw,hh; 
       //获取屏幕的尺寸
       w=getSize().width; 
       h=getSize().height;
       hw=w/2; hh=h/2;
       //在屏幕上输出字符
       g.drawString("Sin[2x]+Cos[3x]",10,40);
       g.setColor(Color.red);  
       g.drawString("0",hw+5,hh+12); 
       g.drawString(""+max,hw-20,40);
       g.drawString(""+max,w-20,hh+12);
       //绘制X轴坐标
       g.drawLine(0,hh,w,hh);
       //绘制Y轴坐标
       g.drawLine(hw,0,hw,h);
       xd=2*max/w;//计算X增量
       yd=hh/max; //计算y增量
       g.setColor(Color.blue);
       //使用增量绘制一小段线，最终组成曲线图形。 
       for (int x=0 ; x<w-1; x++) { 
          x0=-max+x*xd; y0=f(x0)*yd; 
          x1=x0+xd;     y1=f(x1)*yd; 
          g.drawLine(x,(int)(hh-y0),x+1,(int)(hh-y1));
       } 
  }
 } //end

view plainprint?

package test28;
import javax.swing.*;
import java.awt.*;
/**
* Title: 图片的处理，
* Description: 将图片放大和翻转显示
* Filename: ImgDemo.java
*/
class ImgDemo extends JFrame {
private static final long serialVersionUID = 1L;
Image image;
/**
*方法说明：构造器，显示窗体
*输入参数：
*返回类型：
*/
@SuppressWarnings("deprecation")
ImgDemo(String filename) {
setTitle("drawImage Example");
try {
image = getToolkit().getImage(filename);
setIconImage(image);
} catch (Exception e) {
e.printStackTrace();
}
setSize(600, 250);
setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
show();
}
/**
*方法说明：绘制图像
*输入参数：
*返回类型：
*/
public void paint(Graphics g) {
Insets insets = getInsets();
int x = insets.left, y = insets.top;
//获取图片尺寸
int w = image.getWidth(this);
int h = image.getHeight(this);
//正常显示图片
g.drawImage(image, x, y, this);
//缩小图形
g.drawRect(x, y, w/4+1, h/4+1);//画一个框
g.drawImage(image, x+1, y+1, w/4, h/4, this);
//水平翻转
g.drawImage(image, x+w, y, x+2*w, y+h, w, 0, 0, h, this);
}
/**
*方法说明：主方法，接受参数
*输入参数：
*返回类型：
*/
public static void main(String[] args) {
if (args.length == 1) {
new ImgDemo(args[0]);
} else {
System.err.println("usage: java ImgDemo images-name ");
}
}
}

package test28;

import javax.swing.*;
import java.awt.*;
/**
 * Title: 图片的处理，
 * Description: 将图片放大和翻转显示
 * Filename: ImgDemo.java
 */
class ImgDemo extends JFrame {

	private static final long serialVersionUID = 1L;
Image image;
/**
 *方法说明：构造器，显示窗体
 *输入参数：
 *返回类型：
 */
@SuppressWarnings("deprecation")
ImgDemo(String filename) {
setTitle("drawImage Example");
try {
  image = getToolkit().getImage(filename);
  setIconImage(image);
} catch (Exception e) {
  e.printStackTrace();
}

setSize(600, 250);
setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
show();
}
/**
 *方法说明：绘制图像
 *输入参数：
 *返回类型：
 */
public void paint(Graphics g) {
  Insets insets = getInsets();
  int x = insets.left, y = insets.top;
  //获取图片尺寸
  int w = image.getWidth(this);
  int h = image.getHeight(this);
  //正常显示图片
  g.drawImage(image, x, y, this); 
  //缩小图形
  g.drawRect(x, y, w/4+1, h/4+1);//画一个框
  g.drawImage(image, x+1, y+1, w/4, h/4, this);
  //水平翻转
  g.drawImage(image, x+w, y, x+2*w, y+h, w, 0, 0, h, this);
}
/**
 *方法说明：主方法，接受参数
 *输入参数：
 *返回类型：
 */
public static void main(String[] args) {
 if (args.length == 1) {
  new ImgDemo(args[0]);
 } else {
  System.err.println("usage: java ImgDemo images-name ");
 }
}
}

view plainprint?

package test29;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.*;
import javax.swing.Timer;
/**
* Title: 时钟
* Description: 本实例演示使用图形绘制一个图形时钟
* Filename: Clock.java
*/
public class Clock extends JFrame implements ActionListener{
private static final long serialVersionUID = 1L;
Timer timer;
int x,y,old_X,old_Y, r,x0,y0,w,h,ang;
int sdo,mdo,hdo,old_M,old_H;
TimeZone tz =TimeZone.getTimeZone("JST");
final double RAD=Math.PI/180.0;
public static void main(String[] args){
@SuppressWarnings("unused")
Clock cl = new Clock();
}
/**
*方法说明：实现ActionListener类必须过载的方法
*输入参数：
*返回类型：
*/
public void actionPerformed(ActionEvent e) {
timer.restart();
}
/**
*方法说明：构造器，显示窗体，并添加了一个秒表
*输入参数：
*返回类型：
*/
@SuppressWarnings("deprecation")
Clock(){
super("Clock");
setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
setBackground(new Color(0,0,192));
setSize(300,300);
show();
int delay = 1000;
//窗体添加事件监听，监听秒表的触发
ActionListener taskPerformer = new ActionListener() {
public void actionPerformed(ActionEvent evt) {
repaint();
}
};
new Timer(delay, taskPerformer).start();
}
/**
*方法说明：绘制图形
*输入参数：
*返回类型：
*/
public void paint( Graphics g ) {
Insets insets = getInsets();
int L0 = (insets.left)/2, T0 = (insets.top)/2;
int hh,mm,ss;
String st;
h=getSize().height;
//绘制圆形
g.setColor(Color.white);
g.drawOval(L0+30,T0+30,h-60,h-60);
g.drawOval(L0+32,T0+32,h-64,h-64);
r=h/2-30;
x0=30+r-5+L0;
y0=30+r-5-T0;
ang=60;
for (int i=1; i<=12; i++) {
x=(int)((r+10)*Math.cos(RAD*ang)+x0);
y=(int)((r+10)*Math.sin(RAD*ang)+y0);
g.drawString(""+i,x,h-y);
ang-=30;
}
x0=30+r+L0; y0=30+r+T0;
//获取时间
Calendar now=Calendar.getInstance();
hh=now.get(Calendar.HOUR_OF_DAY);//小时
mm=now.get(Calendar.MINUTE);//分钟
ss=now.get(Calendar.SECOND);// 秒
g.setColor(Color.pink);
g.fillRect(L0,T0,60,28);//填充的矩形
g.setColor(Color.blue);
if (hh < 10) st="0"+hh; else st=""+hh;
if (mm < 10) st=st+":0"+mm; else st=st+":"+mm;
if (ss < 10) st=st+":0"+ss; else st=st+":"+ss;
g.drawString(st,L0,T0+25);
//计算时间和图形的关系
sdo=90-ss*6;
mdo=90-mm*6;
hdo=90-hh*30-mm/2;
//擦除秒针
if (old_X > 0) {
g.setColor(getBackground());
g.drawLine(x0,y0,old_X,(h-old_Y));
} else {
old_M=mdo;
old_H=hdo;
}
//绘制秒针
g.setColor(Color.yellow);
x=(int)((r-8)*Math.cos(RAD*sdo)+x0);
y=(int)((r-8)*Math.sin(RAD*sdo)+y0)-2*T0;
g.drawLine(x0,y0,x,(h-y));
old_X=x;
old_Y=y;
//擦除分针和时针
if (mdo != old_M) {
line(g,old_M,(int)(r*0.7),getBackground());
old_M=mdo;
}
if (hdo != old_H) {
line(g,old_H,(int)(r*0.5),getBackground());
old_H=hdo;
}
//绘制分针
line(g,mdo,(int)(r*0.7),Color.green);
//绘制时针
line(g,hdo,(int)(r*0.5),Color.red);
} // end paint
/**
*方法说明：绘制线，用于绘制时针和分针
*输入参数：
*返回类型：
*/
public void line(Graphics g, int t, int n, Color c) {
int [] xp = new int[4];
int [] yp = new int[4];
xp[0]=x0;
yp[0]=y0;
xp[1]= (int)((n-10)*Math.cos(RAD*(t-4))+x0);
yp[1]=h-(int)((n-10)*Math.sin(RAD*(t-4))+y0);
xp[2]= (int)( n *Math.cos(RAD* t )+x0);
yp[2]=h-(int)( n *Math.sin(RAD* t )+y0);
xp[3]= (int)((n-10)*Math.cos(RAD*(t+4))+x0);
yp[3]=h-(int)((n-10)*Math.sin(RAD*(t+4))+y0);
g.setColor(c);
g.fillPolygon(xp,yp,4);
}
}

package test29;

 import java.awt.*; 
 import java.awt.event.*;
 import java.util.*;
 import javax.swing.*;
import javax.swing.Timer;
/**
 * Title: 时钟
 * Description: 本实例演示使用图形绘制一个图形时钟
 * Filename: Clock.java
 */
 public class Clock extends JFrame implements ActionListener{ 

	private static final long serialVersionUID = 1L;
	Timer timer;
    int x,y,old_X,old_Y, r,x0,y0,w,h,ang; 
    int sdo,mdo,hdo,old_M,old_H; 
    TimeZone tz =TimeZone.getTimeZone("JST");
    final double RAD=Math.PI/180.0; 

  public static void main(String[] args){
    @SuppressWarnings("unused")
	Clock cl = new Clock();
  }
/**
 *方法说明：实现ActionListener类必须过载的方法
 *输入参数：
 *返回类型：
 */ 
  public void actionPerformed(ActionEvent e) {
            timer.restart();
    }
/**
 *方法说明：构造器，显示窗体，并添加了一个秒表
 *输入参数：
 *返回类型：
 */ 
  @SuppressWarnings("deprecation")
Clock(){
    super("Clock");
    setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
    setBackground(new Color(0,0,192));
    setSize(300,300);
    show();
    int delay = 1000;
    //窗体添加事件监听，监听秒表的触发
    ActionListener taskPerformer = new ActionListener() {
      public void actionPerformed(ActionEvent evt) {
         repaint();
      }
    };
    new Timer(delay, taskPerformer).start();
  }
/**
 *方法说明：绘制图形
 *输入参数：
 *返回类型：
 */
  public void paint( Graphics g ) { 
  	 Insets insets = getInsets();
     int L0 = (insets.left)/2, T0 = (insets.top)/2;
     int hh,mm,ss; 
     String st; 
     h=getSize().height;
     //绘制圆形
     g.setColor(Color.white); 
     g.drawOval(L0+30,T0+30,h-60,h-60);
     g.drawOval(L0+32,T0+32,h-64,h-64);
     r=h/2-30;
     x0=30+r-5+L0;
     y0=30+r-5-T0;
     ang=60;
     for (int i=1; i<=12; i++) { 
        x=(int)((r+10)*Math.cos(RAD*ang)+x0);
        y=(int)((r+10)*Math.sin(RAD*ang)+y0);
        g.drawString(""+i,x,h-y);
        ang-=30;
     } 
     x0=30+r+L0; y0=30+r+T0;
     //获取时间
     Calendar now=Calendar.getInstance();
     hh=now.get(Calendar.HOUR_OF_DAY);//小时
     mm=now.get(Calendar.MINUTE);//分钟
     ss=now.get(Calendar.SECOND);// 秒
     g.setColor(Color.pink); 
     g.fillRect(L0,T0,60,28);//填充的矩形
     g.setColor(Color.blue); 
     if (hh < 10) st="0"+hh;     else st=""+hh; 
     if (mm < 10) st=st+":0"+mm; else st=st+":"+mm; 
     if (ss < 10) st=st+":0"+ss; else st=st+":"+ss; 
     g.drawString(st,L0,T0+25);
     //计算时间和图形的关系
     sdo=90-ss*6;
     mdo=90-mm*6;
     hdo=90-hh*30-mm/2;
     //擦除秒针
     if (old_X > 0) {
        g.setColor(getBackground());
        g.drawLine(x0,y0,old_X,(h-old_Y));
     } else { 
        old_M=mdo;
        old_H=hdo;
     } 
     //绘制秒针
     g.setColor(Color.yellow); 
     x=(int)((r-8)*Math.cos(RAD*sdo)+x0); 
     y=(int)((r-8)*Math.sin(RAD*sdo)+y0)-2*T0; 
     g.drawLine(x0,y0,x,(h-y));
     
     old_X=x; 
     old_Y=y; 
     //擦除分针和时针
     if (mdo != old_M) {
       line(g,old_M,(int)(r*0.7),getBackground());
       old_M=mdo;
     } 
     if (hdo != old_H) {
       line(g,old_H,(int)(r*0.5),getBackground());
       old_H=hdo;
     } 
     //绘制分针
     line(g,mdo,(int)(r*0.7),Color.green);
     //绘制时针
     line(g,hdo,(int)(r*0.5),Color.red);
  } // end paint 
/**
 *方法说明：绘制线，用于绘制时针和分针
 *输入参数：
 *返回类型：
 */
   public void line(Graphics g, int t, int n, Color c) { 
      int [] xp = new int[4];
      int [] yp = new int[4]; 
      xp[0]=x0;
      yp[0]=y0;
      xp[1]=  (int)((n-10)*Math.cos(RAD*(t-4))+x0); 
      yp[1]=h-(int)((n-10)*Math.sin(RAD*(t-4))+y0); 
      xp[2]=  (int)( n    *Math.cos(RAD* t   )+x0); 
      yp[2]=h-(int)( n    *Math.sin(RAD* t   )+y0); 
      xp[3]=  (int)((n-10)*Math.cos(RAD*(t+4))+x0); 
      yp[3]=h-(int)((n-10)*Math.sin(RAD*(t+4))+y0); 
      g.setColor(c); 
      g.fillPolygon(xp,yp,4);
   }
 }

view plainprint?

package test30;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
/**
* Title: 正方体框图
* Description: 绘制一个边框的正方体，获取鼠标事件根据鼠标的位置旋转方体。
* Filename: Gr3d1m.java
*/
public class Gr3d1m extends JFrame
implements MouseListener,MouseMotionListener {
int doX,doY;
int angX=30,angY=30;
Cube data = new Cube();
Color [] Col={Color.gray,Color.cyan,Color.green,
Color.red,Color.white,Color.orange,
Color.magenta,Color.pink};
/**
*方法说明：主方法
*输入参数：
*返回类型：
*/
public static void main(String[] args){
Gr3d1m G3 = new Gr3d1m();
}
/**
*方法说明：构造器
*输入参数：
*返回类型：
*/
public Gr3d1m() {
setTitle("3D cube Frame");
setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
addMouseListener(this);
addMouseMotionListener(this);
setBackground(new Color(128,128,255));
setSize(350,350);
show();
}
/**
*方法说明：鼠标按下事件，获取鼠标位置
*输入参数：
*返回类型：
*/
public void mousePressed(MouseEvent e) {
doX=e.getX();
doY=e.getY();
}
/**
*方法说明：鼠标托拽事件，改变鼠标位置，重画屏幕
*输入参数：
*返回类型：
*/
public void mouseDragged(MouseEvent e) {
angX=angX+e.getY()-doY;
angY=angY+e.getX()-doX;
doX=e.getX(); doY=e.getY();
repaint();
}
/* 以下是实现MouseListener和MouseMotionListener必须重载的方法*/
public void mouseReleased(MouseEvent e) { }
public void mouseClicked(MouseEvent e) { }
public void mouseEntered(MouseEvent e) { }
public void mouseExited(MouseEvent e) { }
public void mouseMoved(MouseEvent e) { }
/**
*方法说明：绘制图形
*输入参数：
*返回类型：
*/
public void paint( Graphics g ) {
delDeaw(g);
for (int i=0; i<data.x.length; i++) {
drawPG(g, data.x[i], data.y[i], data.z[i],
150,150,Col[i]);
}
g.setColor(Color.yellow);
g.drawString("X="+angX%360+" Y="+angY%360,
10,getSize().height-30);
}
/**
*方法说明：擦拭屏幕，使用背景色覆盖原来的图形
*输入参数：
*返回类型：
*/
public void delDeaw(Graphics g){
Insets insets = getInsets();
int L0 = insets.left, T0 = insets.top;
g.setColor(new Color(128,128,255));
g.fillRect(L0,T0,L0+350,T0+350);
}
/**
*方法说明：绘制方体
*输入参数：
*返回类型：
*/
public void drawPG(Graphics g,double []x,double []y,
double []z,int xp,int yp,Color co) {
double x1,y1,z0;
int len=x.length;
int [] xx=new int [len];
int [] yy=new int [len];
final double RAD=Math.PI/180.0;
double a=angX*RAD;
double b=angY*RAD;
double sinA=Math.sin(a),sinB=Math.sin(b);
double cosA=Math.cos(a),cosB=Math.cos(b);
for (int i=0; i<len; i++) {
x1= x[i]*cosB+z[i]*sinB;
z0=-x[i]*sinB+z[i]*cosB;
y1= y[i]*cosA- z0*sinA;
xx[i]=xp+(int)Math.rint(x1);
yy[i]=yp-(int)Math.rint(y1);
}
g.setColor(co);
g.drawPolygon(xx,yy,len);//绘制多边形
}
}

100个Java经典例子（21-30）初学者的利器高手的宝典JavaSE，21-30javase

100个Java经典例子（21-30）初学者的利器高手的宝典JavaSE，21-30javase

相关文章

相关文章

用户点评