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

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.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 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 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 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 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 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 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 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 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 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);//绘制多边形
  }
 }