Java实现简单小画板_Java教程

Java制作简单画板，包括两个类，一个主要画板类Drawpad，一个画板监听器DrawListener类。

1、Drawpad类，包括画板，画板功能设计，保存图片等

				?

									package Java课程设计;

									import java.awt.Graphics;

									import javax.imageio.ImageIO;

									import javax.print.DocFlavor.STRING;

									import javax.swing.ImageIcon;

									import javax.swing.JDialog;

									import javax.swing.JFileChooser;

									import javax.swing.JFrame;

									import javax.swing.JLabel;

									import javax.swing.JMenu;

									import javax.swing.JMenuBar;

									import javax.swing.JMenuItem;

									import javax.swing.JOptionPane;

									import javax.swing.JPanel;

									import javax.swing.JTextArea;

									import javax.swing.JTextField;

									import javax.swing.UIManager;

									import javax.swing.UnsupportedLookAndFeelException;

									import java.awt.AWTException;

									import java.awt.BasicStroke;

									import java.awt.BorderLayout;

									import java.awt.Color;

									import java.awt.Component;

									import java.awt.Container;

									import java.awt.Dimension;

									import java.awt.Font;

									import java.awt.Graphics2D;

									import java.awt.Rectangle;

									import java.awt.Robot;

									import java.awt.Shape;

									import java.awt.Window;

									import java.awt.event.ActionEvent;

									import java.awt.event.ActionListener;

									import java.awt.image.BufferedImage;

									import java.awt.image.ColorModel;

									import java.io.File;

									import java.io.FileInputStream;

									import java.io.FileNotFoundException;

									import java.io.IOException;

									import java.util.ArrayList;

									import javax.swing.JButton;

									import javax.swing.filechooser.FileNameExtensionFilter;

									public class Drawpad {

									     static Color color1;

									public static void main(String[] args) {

									    Drawpad dp = new Drawpad();

									    dp.initUI();

									}  

									   //创建一个JFrame图形窗口

									    public void initUI() {

									        JFrame jf = new JFrame();

									        jf.setTitle("创意画图板(勿拖动)");

									        jf.setSize(1500,1000);

									        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//关闭时退出

									        jf.setLocationRelativeTo(null);//居中，不用定位窗口大小

									        //创建字体，之后所有的字体为该字体

									        Font f=new Font("方正仿宋简体", Font.BOLD, 20);

									        //创建画笔监听器

									        DrawListener  dl = new DrawListener();

									        //创建读取图片BufferedImage(将图片加载到drawPanel面板中)和画笔g，画笔g为在保存图片上进行图画。

									                BufferedImage bi = new BufferedImage(1300,800, BufferedImage.TYPE_INT_ARGB);

									                Graphics2D g = bi.createGraphics();

									                //初始化时填充白色

									                g.setColor(Color.WHITE);

									                //先将图片填充为白色

									                g.fillRect(0, 0, 1300,800);

									        //设置增加菜单栏，包括保存和新建两个按钮

									        JMenuBar box=new JMenuBar();

									        //在窗体上加菜单条,做一个菜单条,是菜单条，不是工具栏

									        //创建menubtn1保存按钮，并加上监听器，以图片的形式保存绘画板上的内容

									        JButton menubtn1=new JButton("保存");

									        //为保存按钮注册监听器

									          menubtn1.addActionListener(new ActionListener(){

									                 @Override

									                 public void actionPerformed(ActionEvent arg0) {

									                     //创建文件保存窗口

									                     JFileChooser f=new JFileChooser("保存");

									                     int returnVal = f.showSaveDialog(null);

									                    File    file1=null;

									                    if(returnVal == JFileChooser.APPROVE_OPTION) {

									                        file1 =f.getSelectedFile();

									                        String name = f.getName(file1);

									                        try {

									                            ImageIO.write(bi, "PNG", new File(f.getCurrentDirectory(),name+".png"));

									                        } catch (IOException e) {

									                            //需抛出异常

									                            // TODO Auto-generated catch block

									                            e.printStackTrace();

									                        }

									                    }

									                 }

									              });

									         /*JButton menubtn2=new JButton("打开");

									          //为打开按钮注册监听器

									          menubtn1.addActionListener(new ActionListener(){

									               @Override

									               //获取当前画笔粗细

									               public void actionPerformed(ActionEvent arg0) {

									                   BufferedImage bimg = null;

									                   JFileChooser f=new JFileChooser("打开");

									                 int returnVal = f.showOpenDialog(null);

									                File    file1=null;

									                if(returnVal == JFileChooser.APPROVE_OPTION) {

									                    file1 =f.getSelectedFile();

									                    String name = f.getName(file1);

									                    try {

									                    } catch (IOException e) {

									                        // TODO Auto-generated catch block

									                        e.printStackTrace();

									                    }

									                }

									               }

									            });*/

									        //创建menubtn3退出按钮，并加上监听器，退出程序

									          JButton menubtn3=new JButton("退出");

									          menubtn3.addActionListener(new ActionListener(){

									                   @Override

									                   //获取当前画笔粗细

									                   public void actionPerformed(ActionEvent arg0) {

									                       int ret=JOptionPane.showConfirmDialog(null, "你确定要退出吗", "确认退出", JOptionPane.YES_NO_OPTION);

									                       if(ret==JOptionPane.YES_OPTION){

									                           //“确认”退出程序

									                           System.exit(0);

									                       }

									                   }

									                });

									          box.add(menubtn1);

									         // box.add(menubtn2);

									          box.add(menubtn3);

									        //jf.setJMenuBar(box);

									        jf.setJMenuBar(box);

									        //jf用BorderLayout布局

									        //北边,画板模式功能栏

									        JPanel funcPanel=new JPanel();

									        jf.add(funcPanel,BorderLayout.NORTH);

									        //中间,画布

									        JPanel drawPanel=new JPanel();

									        jf.add(drawPanel,BorderLayout.CENTER);

									        drawPanel.setPreferredSize(new Dimension(1000,700));

									        drawPanel.setBackground(dl.background);

									        //一定要在画布上加上监听器!!1若画布没有加上监听器，无法显示

									        drawPanel.addMouseListener(dl);

									        drawPanel.addMouseMotionListener(dl);

									        //南边,为画笔颜色选择按钮

									        JPanel colorPanel=new JPanel();

									        jf.add(colorPanel,BorderLayout.SOUTH);

									        //右边,为选择背景颜色按钮、画笔粗细选择按钮

									        JPanel backgroundPanel=new JPanel();

									        jf.add(backgroundPanel,BorderLayout.EAST);

									        backgroundPanel.setPreferredSize(new Dimension(150,1000));

									        //左边,获取当前状态如:背景颜色、画笔颜色、画笔性质

									        JPanel nowPanel=new JPanel();

									        jf.add(nowPanel,BorderLayout.WEST);

									        nowPanel.setPreferredSize(new Dimension(180,1000));

									        //左边放入当前状态Panel

									        nowPanel.setBackground(Color.WHITE);

									         JLabel label2=new JLabel("当前背景颜色");

									          label2.setFont(f);

									           nowPanel.add(label2);

									           //放入当前背景颜色

									           JButton nowbackgroundColor=new JButton();

									           nowbackgroundColor.setPreferredSize(new Dimension(60,60));

									           nowbackgroundColor.setBackground(Color.WHITE);//背景初始化为灰色

									           nowPanel.add(nowbackgroundColor);

									           //放入当前画笔

									           JLabel label3=new JLabel("请选择画笔模式");

									              label3.setFont(f);

									               nowPanel.add(label3);

									           //放入当前画笔颜色

									           JButton nowColor=new JButton();

									           nowColor.setPreferredSize(new Dimension(60,60));

									           nowColor.setBackground(Color.BLACK);//画笔颜色初始化为黑色色

									           nowPanel.add(nowColor);

									            //获取当前画笔模式

									            JLabel label4=new JLabel("当前画笔模式");

									              label4.setFont(f);

									               nowPanel.add(label4);

									               JTextField text=new JTextField(dl.btncontent); //获得选择画笔模式的按钮内容，得到当前画笔模式

									               text.setPreferredSize(new Dimension (160,60));

									               text.setFont(f);

									               text.setEditable(false);  //不可改

									            nowPanel.add(text);

									            //获取当前画笔粗细状态

									            JLabel label6=new JLabel("当前画笔粗细(中)");  //默认粗细为中

									              label6.setFont(f);

									               nowPanel.add(label6);

									               JTextField text1=new JTextField("请选择画笔粗细");

									               text1.setPreferredSize(new Dimension (160,60));

									               text1.setFont(f);

									               text1.setEditable(false); //不可编辑

									            nowPanel.add(text1);

									            //输入需要添加的文字

									            JLabel label7=new JLabel("请输入文字:");

									              label7.setFont(f);

									               nowPanel.add(label7);

									               JTextField text2=new JTextField();

									               text2.setPreferredSize(new Dimension (160,60));

									               text2.setFont(f);

									               nowPanel.add(text2); 

									               JLabel label8=new JLabel("请输入文字样式:");

									                  label8.setFont(f);

									                   nowPanel.add(label8);

									                   JTextField text3=new JTextField("方正仿宋简体");

									                   text3.setPreferredSize(new Dimension (160,60));

									                   text3.setFont(f);

									                   nowPanel.add(text3);

									                   JLabel label9=new JLabel("请输入文字大小:");

									                      label9.setFont(f);

									                       nowPanel.add(label9);

									                       JTextField text4=new JTextField("20");

									                       text4.setPreferredSize(new Dimension (160,60));

									                       text4.setFont(f);

									                       nowPanel.add(text4);

									            //为获取文字内容加一个按钮并加上监听器

									               JButton getcontent=new JButton("获取文字");

									               getcontent .setFont(f);

									                getcontent.setBackground(Color.YELLOW);

									                getcontent.addActionListener(new ActionListener(){

									                    @Override

									                    public void actionPerformed(ActionEvent e) {

									                         String content=text2.getText();

									                        String mode=text3.getText();

									                        String size=text4.getText();

									                        dl.mode=mode; //获取文字样式

									                           dl.content=content; //获取文字内容

									                           dl.size=size; //获取文字大小

									                    }

									                 });

									                nowPanel.add(getcontent);

									                //最后在当前状态画板中加一个清除画布内容的功能

									                JButton clear=new JButton("清除");

									                  clear.setFont(f);

									                    clear.setBackground(Color.RED);

									                    clear.addActionListener(dl);

									                    nowPanel.add(clear);

									        //添加按钮到北边（每个按钮写两行代码太多，通过数组方式添加按钮）

									                //加入标签（选择画笔模式）

									                JLabel labelh =new JLabel("选择画笔模式");

									                labelh.setFont(f);

									                funcPanel.add(labelh);

									                //将按钮名字保存在数组中，后依次存储

									        String[] btnstr= {"画笔","直线","矩形","填充矩形","圆","填充圆","弧线","喷枪","波形","分形","长方体","九宫格递归","文字","橡皮"};

									        //将画笔状态按钮防置panel中

									        for( int i=0;i<btnstr.length;i++) {

									            JButton btn=new JButton(btnstr[i]);

									            funcPanel.add(btn);

									            btn .setFont(f);

									            btn.setBackground(Color.white);

									            //加上画笔监听器

									            btn.addActionListener(dl);

									            //加上监听器：获取当前 画笔模式

									            btn.addActionListener(new ActionListener(){

									                @Override

									                public void actionPerformed(ActionEvent e) {

									                    text.setText(btn.getText()); //在当前模式加入选取的画笔模式

									                }

									             });

									        };

									        //在BrderLayout布局SOUTH添加选择颜色按钮

									        JLabel label =new JLabel("选择画笔(橡皮)颜色");

									        label.setFont(f);

									        colorPanel.add(label);

									         //添加颜色按钮

									        Color[] colorArray = { Color.BLUE, Color.GREEN, Color.RED, 

									                Color.BLACK,Color.ORANGE,Color.PINK,Color.CYAN,

									                Color.MAGENTA,Color.DARK_GRAY,Color.GRAY,

									                Color.LIGHT_GRAY,Color.YELLOW,Color.WHITE};

									        //在布局管理器中添加颜色按钮

									        for( int i=0;i<colorArray.length;i++) {

									            JButton button = new JButton();

									            button.setBackground(colorArray[i]);

									            button.setPreferredSize(new Dimension(50, 50));

									            button.addActionListener(dl);

									            colorPanel.add(button);

									            //获取当前状态的画笔颜色

									            button.addActionListener(new ActionListener(){

									                @Override

									                public void actionPerformed(ActionEvent e) {

									                    nowColor.setBackground(button.getBackground());  //在当前画笔颜色按钮加入选择的按钮颜色

									                }

									             });

									        };

									      funcPanel.setBackground(Color.gray);

									      //添加背景主板颜色按钮，并设置监听器（背景颜色为按钮颜色）

									      JLabel label1=new JLabel("选择背景颜色");

									      label1.setFont(f);

									       backgroundPanel.add(label1);

									      Color[] backgroundArray= { Color.GREEN, Color.RED,

									          Color.ORANGE,Color.PINK,Color.CYAN,

									              Color.MAGENTA,Color.DARK_GRAY,Color.GRAY,

									              Color.LIGHT_GRAY,Color.YELLOW,Color.WHITE,Color.BLACK};

									      //将按钮加入进去

									      for( int i=0;i<backgroundArray.length;i++) {

									          JButton button = new JButton();

									          button.setBackground(backgroundArray[i]);

									          button.setPreferredSize(new Dimension(50, 50));

									          backgroundPanel.add(button);

									          //添加监听器，按下按钮改变背景颜色，同时体现当前状态

									        button.addActionListener(new ActionListener(){

									            @Override

									            public void actionPerformed(ActionEvent arg0) {

									                drawPanel.setBackground(button.getBackground()); //将背景颜色改为选取的背景颜色

									                color1=button.getBackground();

									                dl.background=color1;  //将背景颜色传给DrawListener中的变量

									                System.out.println(color1);

									                g.setColor(color1);

									                g.fillRect(0, 0, 1300,800);  //图片画笔填充背景颜色

									                nowbackgroundColor.setBackground(button.getBackground());

									            }

									         });

									        };

									        //添加选择画笔粗细的按钮,可选择画笔的粗细

									        JLabel label5=new JLabel("选择画笔粗细");

									          label5.setFont(f);

									           backgroundPanel.add(label5);

									           String[] Size={"细","中","粗"};

									           //选择画笔模式的按钮

									           for(int i=0;i<3;i++){

									               JButton graphsize=new JButton(Size[i]);

									               graphsize.setFont(new Font("宋体", Font.BOLD, 15));

									               graphsize.setBackground(Color.WHITE);

									               graphsize.setPreferredSize(new Dimension(50, 50));

									               backgroundPanel.add(graphsize);

									               graphsize.addActionListener(dl);

									               graphsize.addActionListener(new ActionListener(){

									                   @Override

									                   //获取当前画笔粗细

									                   public void actionPerformed(ActionEvent e) {

									                       text1.setText(graphsize.getText()); //获取当前画笔模式

									                   }

									                });

									           }

									        jf.setVisible(true);

									        // 获取这个界面的ｇｒａｐｈｉｃｓ属性, 画笔 g

									        //Graphics2D g = (Graphics2D) drawPanel.getGraphics();

									        //drawPanel.paintComponent(g);

									         Graphics2D g1= (Graphics2D) drawPanel.getGraphics();

									        //为画笔添加监听器

									        drawPanel.addMouseListener(dl);

									        dl.g =  g1;// 右传左 

									        dl.g3 = g;// 右传左

									    }

									}

2、DrawListner类，画板功能监听器

				?

									package Java课程设计;

									import java.awt.BasicStroke;

									import java.awt.Color;

									import java.awt.Container;

									import java.awt.Dimension;

									import java.awt.Font;

									import java.awt.Graphics;

									import java.awt.Graphics2D;

									import java.awt.RenderingHints;

									import java.awt.Shape;

									import java.awt.event.MouseEvent;

									import java.awt.event.MouseListener;

									import java.awt.event.ActionEvent;

									import java.awt.event.ActionListener;

									import java.awt.event.MouseMotionListener;

									import java.awt.geom.AffineTransform;

									import javax.swing.JButton;

									import javax.swing.JFrame;

									import javax.swing.JPanel;

									import javax.swing.JTextField;

									import java.awt.Color;

									import java.util.ArrayList;

									import java.util.Random;

									import Java课程设计.Drawpad;

									public class DrawListener implements MouseListener,ActionListener,MouseMotionListener {

									    //获取画笔

									    Graphics2D g;

									    //获取在保存图片上的画笔

									        Graphics2D g3;

									    //获取按钮内容

									    String btnstr;

									    Color background=Color.white; //背景颜色默认为白色

									    Color graphcolor=Color.BLACK; //画笔颜色默认为黑色

									    JButton btn;

									    int x1, y1, x2, y2;// 声明坐标变量 

									    int x3=400;

									    int y3=0;

									    int graphsize=3;//默认为中等画笔

									    String btncontent="画笔"; //默认画笔模式为画笔

									    String content;  //获取文字中的文字内容

									    String mode="方正仿宋简体";  //文字样式默认为“方正仿宋简体”

									    String size="20";

									    //九宫格递归方法,画出九宫格

									    public void dg(int x,int y,int width,int height) {

									        //九宫格函数，九宫格的实现

									         if(width<3) {

									                return;

									                }

									        if(width>90) {

									        g.fillRect(x+width/3, y+height/3, width/3, height/3);

									        g3.fillRect(x+width/3, y+height/3, width/3, height/3);

									        dg(x, y, width/3, height/3);

									        dg(x+width/3, y, width/3, height/3);

									        dg(x+(width/3)*2, y, width/3, height/3);

									        dg(x, y+height/3, width/3, height/3);

									        dg(x, y+(height/3)*2, width/3, height/3);

									        dg(x+width/3, y+height/3, width/3, height/3);

									        dg(x+width/3, y+(height/3)*2, width/3, height/3);

									        dg(x+(width/3)*2, y+height/3, width/3, height/3);

									        dg(x+(width/3)*2, y+(height/3)*2, width/3, height/3);

									        }

									      //九宫格的实现

									       else {

									           g.drawOval(x+width/3, y+height/3, width/3, height/3);

									           g3.drawOval(x+width/3, y+height/3, width/3, height/3);

									           dg(x, y, width/3, height/3);

									           dg(x+width/3, y, width/3, height/3);

									            dg(x+(width/3)*2, y, width/3, height/3);

									            dg(x, y+height/3, width/3, height/3);

									            dg(x, y+(height/3)*2, width/3, height/3);

									            dg(x+width/3, y+height/3, width/3, height/3);

									            dg(x+width/3, y+(height/3)*2, width/3, height/3);

									            dg(x+(width/3)*2, y+height/3, width/3, height/3);

									            dg(x+(width/3)*2, y+(height/3)*2, width/3, height/3);

									       }    

									    }

									    //判断是颜色按钮还是画笔按钮,改变的全部是画笔按钮

									    public void actionPerformed(ActionEvent e) {

									        btnstr=e.getActionCommand();  //获取按钮的文字内容

									        //g.setColor(Color.black);

									        //如果为颜色按钮，将画笔改颜色

									        if(btnstr.equals("清除")){

									            //重新填充背景，同时将画笔置为背景颜色

									             System.out.println(background);

									            g.setColor(background);//保存图片画笔填充背景颜色

									            g.fillRect(0, 0, 1300, 800);

									            g3.setColor(background);//画笔重新填充背景

									            g3.fillRect(0, 0, 1300, 800);

									            g.setColor(graphcolor);

									            g3.setColor(graphcolor);

									        }

									        else{

									        if(btnstr.equals("")) {

									            //获取点击内容,将其内容强制转换成JButton

									           btn=(JButton) e.getSource();

									            //获取颜色按钮颜色

									           graphcolor=btn.getBackground();

									        }

									        //若为画笔粗细，获取粗细大小

									        else if(btnstr.equals("细")){

									            graphsize=1;  //画笔大小为细，大小size为1

									        }

									        else if(btnstr.equals("中")){

									            graphsize=3;

									        }

									        else if(btnstr.equals("粗")){

									            graphsize=5;

									        }

									        else{

									            btncontent=btnstr; //获取画笔模式按钮的内容

									        }

									        }

									    }

									    //鼠标点击方法

									    @Override

									    public void mouseClicked(MouseEvent e) {

									        System.out.println("点击");

									    }

									   //鼠标按下方法

									    @Override

									    public void mousePressed(MouseEvent e) {

									        System.out.println("按下");

									        x1=e.getX();

									        y1 =e.getY();

									    }

									    //重写鼠标释放时的方法

									    @Override

									    public void mouseReleased(MouseEvent e) {

									        g.setColor(graphcolor);//获取保存画笔的颜色

									        g3.setColor(graphcolor); //获取画板画笔的颜色

									        x2=e.getX();

									        y2 =e.getY();

									        //选取画笔模式为直线时

									        if(btncontent.equals("直线")) {

									            g.setStroke(new BasicStroke(graphsize)); //保存画笔进行画图

									        g.drawLine(x1, y1, x2, y2);//画笔画直线

									        g3.setStroke(new BasicStroke(graphsize));//置画笔大小

									        g3.drawLine(x1, y1, x2, y2);

									        }

									        //选取画笔模式为波形时

									        else if(btncontent.equals("波形")) {

									            //波形函数

									            g.setStroke(new BasicStroke(graphsize)); //置画笔大小

									            g3.setStroke(new BasicStroke(graphsize));

									            double x4 = 0,y4 = 0;

									            double a2=1.40,b2=1.56,c2=1.40,d2=-6.56;

									            //波形函数

									            for(int i=0;i<5000;i++) {

									                double x5=Math.sin(a2*x4)-Math.cos(b2*y4);

									                double y5=Math.sin(c2*x4)-Math.cos(d2*y4);

									                x4=x5;

									                y4=y5;

									                int px=(int)(x5*100+x1);

									                int py=(int)(y5*100+y1);

									                //画波形

									                g.drawLine(px, py, px, py);

									                g3.drawLine(px, py, px, py);

									                }

									        }

									        //选取画笔模式为矩形时

									        else if(btncontent.equals("矩形")) {

									            g.setStroke(new BasicStroke(graphsize)); //获取矩形画笔的大小

									            g.drawRect(Math.min(x1, x2), Math.min(y1, y2), Math.abs(x2-x1), Math.abs(y2-y1));//画矩形

									            g3.setStroke(new BasicStroke(graphsize)); 

									            g3.drawRect(Math.min(x1, x2), Math.min(y1, y2), Math.abs(x2-x1), Math.abs(y2-y1));

									        }

									        //选取的画笔模式为填充矩形

									        else if(btncontent.equals("填充矩形")){

									            //画填充矩形

									            g.fillRect(Math.min(x1, x2), Math.min(y1, y2), Math.abs(x2-x1), Math.abs(y2-y1));

									            g3.fillRect(Math.min(x1, x2), Math.min(y1, y2), Math.abs(x2-x1), Math.abs(y2-y1));

									        }

									        //长方体函数

									        else if(btncontent.equals("长方体")){

									            g.setStroke(new BasicStroke(graphsize));//获取长方体画笔大小

									             g.setColor(btn.getBackground());//将画笔颜色置选择画笔颜色按钮颜色

									             //长方体函数

									                g.fillRect(Math.min(x1,x2),Math.min(y1,y2),Math.abs(x1-x2),Math.abs(y1-y2));

									                g3.setStroke(new BasicStroke(graphsize));

									                 g3.setColor(btn.getBackground());

									                    g3.fillRect(Math.min(x1,x2),Math.min(y1,y2),Math.abs(x1-x2),Math.abs(y1-y2));

									                int a,b,c,d;

									                a=Math.min(x1, x2);

									                b=Math.max(x1, x2);

									                c=Math.min(y1, y2);

									                d=Math.max(y1, y2);

									                int m=(int)((b-a)*Math.cos(Math.PI/4)*Math.sin(Math.PI/4));

									                int n=(int)((b-a)*Math.cos(Math.PI/4)*Math.sin(Math.PI/4));

									                //顶面

									                g.setColor(btn.getBackground());

									                g.fillPolygon(new int[] {a, a+m, b+m,b},new int[] {c,c-n,c-n,c},4);

									                //右侧面

									                g.setColor(btn.getBackground());

									                g.fillPolygon(new int[] {b, b, b+m,b+m},new int[] {c,d,d-n,c-n},4);

									                g3.setColor(btn.getBackground());

									                g3.fillPolygon(new int[] {a, a+m, b+m,b},new int[] {c,c-n,c-n,c},4);

									                //右侧面

									                g3.setColor(btn.getBackground());

									                g3.fillPolygon(new int[] {b, b, b+m,b+m},new int[] {c,d,d-n,c-n},4);

									        }

									        //分形函数

									        else if(btncontent.equals("分形")){

									            g.setStroke(new BasicStroke(graphsize));  //获取画笔大小

									            g3.setStroke(new BasicStroke(graphsize));

									            double x = 0,y = 0;

									            //分形函数实现

									            double a1=-1.8,b=-2.0,c=-0.5,d=-0.9;

									            for(int i=0;i<5000;i++) {

									            double x3=Math.sin(a1*y)-c*Math.cos(a1*x);

									            double y3=Math.sin(b*x)-d*Math.cos(b*y);

									            x=x3;

									            y=y3;

									            int px=(int)(x3*100+x1);

									            int py=(int)(y3*100+y1);

									            g.drawLine(px, py, px, py);

									            g3.drawLine(px, py, px, py);

									        }

									        }

									        //画圆

									        else if(btncontent.equals("圆")) {

									            g.setStroke(new BasicStroke(graphsize));//获取画笔大小

									            g.drawOval(Math.min(x1, x2), Math.min(y1, y2), Math.abs(x2-x1), Math.abs(y2-y1));//画圆

									            g3.setStroke(new BasicStroke(graphsize));

									            g3.drawOval(Math.min(x1, x2), Math.min(y1, y2), Math.abs(x2-x1), Math.abs(y2-y1));

									        }

									        //画填充圆

									        else if(btncontent.equals("填充圆")){

									            g.fillOval(Math.min(x1, x2), Math.min(y1, y2), Math.abs(x2-x1), Math.abs(y2-y1));//画填充圆

									            g3.fillOval(Math.min(x1, x2), Math.min(y1, y2), Math.abs(x2-x1), Math.abs(y2-y1));

									        }

									        //当选取模式为文字

									        else if(btncontent.equals("文字")){

									            //获取画笔大小

									            g.setStroke(new BasicStroke(15));

									        Font font = new Font(mode, Font.BOLD, Integer.parseInt(size)); //获得文字内容，文字大小，文字样式    

									         g.setFont(font); //在画笔中置文字样式和大小

									            g.drawString(content, x1, y1); //写上文字内容

									            g3.setStroke(new BasicStroke(15));

									             g3.setFont(font);//放入文字样式和大小

									            g3.drawString(content, x1, y1);

									        }

									        //当画笔模式为弧线时

									        else if(btncontent.equals("弧线")){

									            g.setStroke(new BasicStroke(graphsize));//获取画笔大小

									            //弧线函数

									             g.drawArc(x1, y1, 100, 60, 0, 180);

									             g3.setStroke(new BasicStroke(graphsize));

									             g3.drawArc(x1, y1, 100, 60, 0, 180);

									        }

									        //九宫格递归，调用九宫格函数

									        else if(btncontent.equals("九宫格递归")) {

									            //九宫格递归实现

									              dg(0,50,600,600);

									          }

									        System.out.println("释放");

									    }

									    @Override

									    //鼠标进入方法

									    public void mouseEntered(MouseEvent e) {

									        System.out.println("进入");

									    }

									    @Override

									    //鼠标离开界面方法

									    public void mouseExited(MouseEvent e) {

									        System.out.println("离开");

									    }

									    @Override

									    public void mouseMoved(MouseEvent e) {

									    }

									    //重写鼠标移动函数

									    @Override

									    public void mouseDragged(MouseEvent e) {

									        g.setColor(graphcolor); //获取画笔颜色

									        g3.setColor(graphcolor);

									        // TODO Auto-generated method stub

									        x2=e.getX();

									        y2 =e.getY();

									        //当为画笔时

									        if(btncontent.equals("画笔")){

									        g.setStroke(new BasicStroke(graphsize));    //获取当前画笔大小        

									        //画笔实现

									                g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

									                g.drawLine(x1, y1, x2, y2);

									                g3.setStroke(new BasicStroke(graphsize));            

									                g3.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

									                g3.drawLine(x1, y1, x2, y2);

									                x1 = x2;

									                y1 = y2;

									                }

									        //橡皮擦

									         if(btncontent.equals("橡皮")){

									             //将画笔颜色置为背景颜色

									             g.setColor(background);

									             g3.setColor(background);

									            g.setStroke(new BasicStroke(30));    //将橡皮擦的大小置大小为30                        

									            g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

									            g.drawLine(x1, y1, x2, y2);

									            g3.setStroke(new BasicStroke(30));                            

									            g3.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

									            g3.drawLine(x1, y1, x2, y2);

									            x1 = x2;

									            y1 = y2;   

									            //使用过后，将画笔颜色重新置为原来颜色

									            g.setColor(graphcolor);

									            g3.setColor(graphcolor);

									        }

									         //喷枪函数

									        else if(btncontent.equals("喷枪")){

									                g.setStroke(new BasicStroke(graphsize));      //不用加粗，获取画笔大小                        

									                g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

									                g3.setStroke(new BasicStroke(graphsize));      //不用加粗                        

									                g3.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

									                //喷枪实现函数

									                for(int k=0;k<20;k++){

									                    Random i=new Random();       

									                    int a=i.nextInt(10);

									                    int b=i.nextInt(20);

									                    g.drawLine(x2+a, y2+b, x2+a, y2+b);

									                    g3.drawLine(x2+a, y2+b, x2+a, y2+b);

									        }

									        }

									    }

									}