java 画板分析设计及完整源码

最新推荐文章于 2024-08-16 17:49:51 发布
最新推荐文章于 2024-08-16 17:49:51 发布
阅读量2k 收藏 30
点赞数 6
分类专栏： Java 文章标签： java 编程语言 gui
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45849888/article/details/109655261
版权

文章目录


完整源代码放在最后

1.画板构成及架构方式

1.1 构成

首先来看一下我所写的画板项目由哪些包构成：
1

  1. entry包是程序的入口（也就是main方法所在的地方）
    它的内容十分简单，如下：
    2
  2. 然后先说window包，顾名思义这个包里面定义了我们画板窗口的显示外观，我们可以称这一部分为“前端”。
    画板的外观是这个样子的：
    3
    对于java的gui设计我不是很习惯，比如其中一些布局什么的，而且swing也不是类似于c++ qt框架这种可视化编程，所以设计出来的GUI也就没有那么好看。
  3. 有了画板的外观后，我们需要对画板上发生的事件进行监听。例如：在用户点击“直线”后，我们需要将画笔的模式调整到直线，在点击颜色“红色”后程序也需要将画笔颜色设置为红色等等。这些工作需要我们对鼠标进行监听，以实现某些特定的功能，而mouseListner包就是负责完成这样的工作。
  4. 最后一个要说的包是repaint包，我之所以给它命名为repaint是它在画板重绘的过程中起到了至关重要的作用（包括画板撤销这一功能中也起了很大作用）。它是我们画出来的图形的载体，例如，我们用画笔画出来一条直线，这时候我们就创建了一个repaint对象，它保存了这条直线的一些关键参数（起始位置，结束位置，线条粗细，线条颜色等信息）让我们可以在重绘的时候可以把这条直线重新画出来；画了一个圆，那么我们也需要保存下这个圆的关键参数。

1.2 架构方式

那么有了以上这些东西，我们如何把一个画板构建起来？我的思路是这样的：

  1. 把画板显示出来–>建立一个画板类，负责显示画板
  2. 给画板上的控件添加监听–>建立一个监听类，负责监听画板控件
  3. 重写画板的重绘函数以及实现撤销功能–>建立一个repaint类
  4. 最后，建立一个entry类，作为程序的入口

2.一个优化

2.1 窗口重绘机制

这里我们有必要提到提到java窗口的重绘机制。在我们将窗口最小化到任务栏后再点开，在我们将窗口最大化，在我们改变窗口大小，这些时候，窗口对象都会自动调用一个重绘函数paint()，它会重现绘画窗口的各部分控件，但是我们使用画笔画出来的所有图像都是不会被自动重绘的，所以这需要我们重写原有的重绘函数让窗口可以正常显示。

2.2 引发的问题

因为每次我们改变窗口大小，所有内容都要被重新绘制，当内容很少时还无伤大雅，但是当内容一多，程序运行就会非常缓慢（慢到你可以很清楚地看到看到你之前所画的所有内容从无到有被慢慢画出来，非常影响使用体验）。在撤销的时候也存在同样的问题，我们将所有画出来的东西都保存为一个个的对象，存到一个vector中，这样重绘的时候我们遍历vector按照其中保存下的关键参数重新绘制这些内容，在撤销时，我们将vector末尾的元素删除，再调用重绘函数，此时就可以达到重绘的目的。但同样的，只要内容一多我们调用重绘函数就会非常缓慢。

2.3 优化

这个优化也只能在一定程度上缓解这一问题，不能彻底解决，当内容一多依然会引发同样的问题。思路是在调用重绘函数重新绘制所有内容的时候使用多线程，将vector分为四部分同时进行绘制，这样能将重绘的时间缩短到原有时间的1/4，使用体验有所改善。

对此大家有什么好的解决方法可以在评论区一起交流

3.知识点梳理

那么要做到以上内容你需要掌握哪些知识点？

  1. 程序设计：java基础，Vector容器
  2. 窗口设计：swing库的基本操作
  3. 利用画笔画图：awt库的基本操作
  4. 简单了解窗口的一些机制

4.源代码

4.1 runtime environment

我的运行环境：eclipse+java jdk14.02

4.2 source code

源代码一共由4个源文件构成，一共696行代码。
ProgramEntry.java:9行代码

package entry;

import window.Outlook;

public class ProgramEntry {
	public static void main(String[] args) {
		Outlook windowObj = new Outlook();
	}
}

Outlook.java:231行代码

package window;

import java.awt.BasicStroke;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.util.Vector;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.border.MatteBorder;

import mouseListener.MouseListener_;
import repaint.Repaint;

public class Outlook extends JFrame {
	MouseListener_ ml;
	public Graphics g;
	public JTextField inputText;
	public JTextField gSizeDisplay;
	public JPanel jpDrawZone;
	public Graphics2D g2d;
	
	
	// 存储画下的图形
	public Vector<Repaint> imgStore = new Vector<Repaint>();
	
	public Outlook() {
		// 设置窗体属性
		this.setTitle("Drawing Board");
        this.setSize(950, 610);
        this.setLocationRelativeTo(null);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setVisible(true);

        JPanel jpFunc = new JPanel();
        JPanel jpColor = new JPanel();
        jpDrawZone = new JPanel();
        JPanel jpUpZone = new JPanel();
        
        ml = new MouseListener_(this); //传递窗体对象
		this.addMouseListener(ml); 
		this.addMouseMotionListener(ml);

		// 添加形状
        String[] funcArray = {"straight line", "curve", "rectangle","circle","text", "image", "eraser"};
        for(int i=0;i<funcArray.length;i++) {
            JButton button = new JButton(funcArray[i]);
            button.setPreferredSize(new Dimension(80,30));
            jpFunc.add(button);
            button.addActionListener(ml);
        }
        
        // 添加颜色
        String[] colorSet = {"black", "red", "green", "blue"};
        Color[] colorArray = {Color.black, Color.red,Color.green,Color.blue};
        for(int i=0;i<colorArray.length;i++) {
            JButton button = new JButton();
            button.setBackground(colorArray[i]);
            button.setPreferredSize(new Dimension(30,30));
            button.setText(colorSet[i]);
            jpColor.add(button);
            button.addActionListener(ml);
        }
        
        // 添加 改变画笔大小
        String[] gSizeChange = {"+", "-"};
        for(int i=0;i<gSizeChange.length;i++) {
            JButton button = new JButton(funcArray[i]);
            button.setPreferredSize(new Dimension(50,30));
            button.setText(gSizeChange[i]);
            jpColor.add(button);
            button.addActionListener(ml);
        }

        // 显示画笔大小
        JLabel sizeText = new JLabel("size:");
		sizeText.setPreferredSize(new Dimension(40,30));
		jpColor.add(sizeText);
		gSizeDisplay = new JTextField("1");
		gSizeDisplay.setPreferredSize(new Dimension(30,30));
		gSizeDisplay.setEditable(true);
		jpColor.add(gSizeDisplay);
        
        // 添加画布
        JLabel drawZone = new JLabel();
        jpDrawZone.add(drawZone);
        jpDrawZone.setBackground(Color.white);
        
        // 控制大小和布局
        //jpFunc.setBounds(100, 10, 800, 40);
        //jpColor.setBounds(100, 55, 800, 30);
        jpUpZone.setLayout(new BorderLayout());
        jpUpZone.add(jpFunc, BorderLayout.NORTH);
        jpUpZone.add(jpColor, BorderLayout.CENTER);
        //jpDrawZone.setBounds(10, 95, 900, 460);
        jpDrawZone.setBorder(new MatteBorder(5,5,5,5,Color.black)); // 给画布设置边界
        this.getContentPane().add(jpUpZone, BorderLayout.NORTH);
        this.getContentPane().add(jpDrawZone, BorderLayout.CENTER);
        
        // 添加文本输入框
        inputText = new JTextField();
        inputText.setEditable(true); // 可直接编辑画笔大小
        this.getContentPane().add(inputText, BorderLayout.SOUTH);
        
        // 设置菜单栏
        JMenuBar jmb = new JMenuBar();
        this.setJMenuBar(jmb);
        JMenu MORE = new JMenu("more");
        JMenu FONT = new JMenu("font");
        jmb.add(MORE);
        jmb.add(FONT);
        
        JMenuItem SAVE = new JMenuItem("save");
        JMenuItem UNDO = new JMenuItem("undo");
        JMenuItem CLEAR = new JMenuItem("clear");
        MORE.add(SAVE);
        MORE.add(UNDO);
        MORE.add(CLEAR);
        SAVE.addActionListener(ml);
        UNDO.addActionListener(ml);
        CLEAR.addActionListener(ml);
        
        JMenu fontName = new JMenu("font name");
        JMenu fontStyle = new JMenu("font style");
        
        FONT.add(fontName);
        FONT.add(fontStyle);

        // 子菜单
        JMenuItem FONTNAME_1 = new JMenuItem("宋体");
        FONTNAME_1.addActionListener(ml);
        JMenuItem FONTNAME_2 = new JMenuItem("微软雅黑");
        FONTNAME_2.addActionListener(ml);
        JMenuItem FONTNAME_3 = new JMenuItem("黑体");
        FONTNAME_3.addActionListener(ml);
        fontName.add(FONTNAME_1);
        fontName.add(FONTNAME_2);
        fontName.add(FONTNAME_3);
        
        JMenuItem FONTSTYLE_1 = new JMenuItem("plain");
        FONTSTYLE_1.addActionListener(ml);
        JMenuItem FONTSTYLE_2 = new JMenuItem("italic");
        FONTSTYLE_2.addActionListener(ml);
        JMenuItem FONTSTYLE_3 = new JMenuItem("bold");
        FONTSTYLE_3.addActionListener(ml);
        fontStyle.add(FONTSTYLE_1);
        fontStyle.add(FONTSTYLE_2);
        fontStyle.add(FONTSTYLE_3);

        this.setVisible(true);
        
		g = this.getGraphics(); //获取窗口画笔对象
        ml.setG(g); //传递画笔
	}
	
	@Override
	public void paint(Graphics g) {
		super.paint(g);
        g2d = (Graphics2D) g;
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                RenderingHints.VALUE_ANTIALIAS_ON);// 设置画笔抗锯齿

		int gap = imgStore.size()/4-1;
		if (gap!=-1) {
			t1.setBorderAndRun(0, gap);
			t1.setBorderAndRun(gap+1, 2*gap+1);
			t1.setBorderAndRun(2*gap+2, 3*gap+2);
		}
		t1.setBorderAndRun(3*gap+3, imgStore.size()-1);
	}

	// 定义四个多线程对象
	MultiThreadRepaint t1 = new MultiThreadRepaint(),
			t2 = new MultiThreadRepaint(),
			t3 = new MultiThreadRepaint(),
			t4 = new MultiThreadRepaint();
	// 本地内部类，多线程重绘
	class MultiThreadRepaint extends Thread {
		private int bp, ep;
		public MultiThreadRepaint() {
			super();
		}
		
		public void setBorderAndRun(int bp_, int ep_) {
			bp = bp_;
			ep = ep_;
			run();
		}
		
		public void run() {
			for (int i=bp; i<=ep; ++i) {
				Repaint imgObj = imgStore.elementAt(i);
				g2d.setStroke(new BasicStroke(imgObj.gSize));
				g2d.setColor(imgObj.gColor);

				switch(imgObj.pattern) {
					case 0: // straight line
						g2d.drawLine(imgObj.bx, imgObj.by, imgObj.ex, imgObj.ey);
						break;
					case 1:
						g2d.drawRect(Math.min(imgObj.bx,imgObj.ex),Math.min(imgObj.by,imgObj.ey),
								Math.abs(imgObj.bx-imgObj.ex),Math.abs(imgObj.by-imgObj.ey));
						break;
					case 2: //circle
						g2d.drawOval(Math.min(imgObj.bx,imgObj.ex),Math.min(imgObj.by,imgObj.ey),
								Math.abs(imgObj.bx-imgObj.ex),Math.abs(imgObj.by-imgObj.ey));
						break;
					case 3: //text
						g2d.setFont(new Font(imgObj.fontName, imgObj.fontStyle, imgObj.gSize));
						g2d.drawString(imgObj.text, imgObj.bx, imgObj.by);
						break;
					case 4:
						g2d.drawImage(imgObj.imgFile, imgObj.bx, imgObj.by,
								imgObj.ex-imgObj.bx, imgObj.ey-imgObj.by, null); // paste img
						break;
				}
			}
		}
	}
}

MouseListener_.java:295行代码

package mouseListener;

import java.awt.AWTException;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.Robot;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;
import javax.swing.JFileChooser;
import javax.swing.filechooser.FileNameExtensionFilter;

import repaint.Repaint;
import window.Outlook;

public class MouseListener_ implements MouseListener, MouseMotionListener, ActionListener {
	{
		System.setProperty("black", "0x000000");
		System.setProperty("blue", "0x0000ff");
		System.setProperty("red", "0xff0000");
		System.setProperty("green", "0x008000");
	}
	
	private Outlook frame; // 获取窗口的一些属性
	private Graphics2D g; // 画笔
	private Color currentColor=Color.black, previousColor = null; // 画笔颜色
	private int bx,by,ex,ey; // 起始终止位置
	private Integer gSize=1; // 画笔粗细
	private Integer textSize = 20; // 文字大小
	private String shape="curve"; // 要画的形状
	private File imgFile;
	
	private String fontName="宋体"; // 字体名称
	private int fontStyle=0; // 字体风格
	
	private int usrChoose; // 保存打开文件时的用户选择
	private JFileChooser fc;
	
	// steady graphic, old position
	private int ox, oy;
	
	// repaint function flag variable
	private boolean havePrint = false;
	
	private Image img; // 图片文件
	
    public MouseListener_(Outlook frame) {
        this.frame = frame;
    }
	
	public void setG(Graphics g) {
        this.g = (Graphics2D) g;
        this.g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                RenderingHints.VALUE_ANTIALIAS_ON);// 设置画笔开启抗锯齿
        this.g.setStroke(new BasicStroke(gSize));
    }
	
	@Override
	public void actionPerformed(ActionEvent e) {
			String whichItem=e.getActionCommand();
			boolean isText; //更改画笔大小时要使用
			switch(whichItem) {
    			case "black":
    			case "red":
    			case "green":
    			case "blue": 
    				g.setColor(currentColor=Color.getColor(whichItem));
    				break;
    				
    			case "eraser":
    				if (currentColor!=Color.white)
    					previousColor = currentColor;
    				g.setColor(currentColor = Color.white);
    				shape="eraser";
    				break;
    			
    			// 设置画笔颜色
    			case "straight line":
    			case "curve":
    			case "rectangle":
    			case "circle":
    			case "text":
    				frame.gSizeDisplay.setText((whichItem.equals("text")?textSize:gSize)+"");
    				shape = whichItem;
    				g.setColor(previousColor==null?currentColor:(currentColor=previousColor));
    				break;

    			case "+":
    				isText = shape.equals("text");
    				frame.gSizeDisplay.setText(isText?(textSize+=2).toString(): (gSize+=1).toString());
					if (!isText)
						this.g.setStroke(new BasicStroke(gSize.intValue()));
    				break;
    			case "-":
    				isText = shape.equals("text");
    				if (isText && textSize.intValue()<22
    						|| !isText && gSize.intValue()<2)
    					break;
    				frame.gSizeDisplay.setText(isText?(textSize-=2).toString():(gSize-=1).toString());
					if (!isText)
						this.g.setStroke(new BasicStroke(gSize.intValue()));
    				break;
    			case "image":
    				fc = new JFileChooser();
    				fc.setFileFilter(new FileNameExtensionFilter("image(*.jpg, *.png, *.jpeg)", "jpg", "png", "jpeg"));
    				fc.setFileSelectionMode(JFileChooser.FILES_ONLY);
    				usrChoose = fc.showOpenDialog(null);
    				if (usrChoose==JFileChooser.OPEN_DIALOG) {
    					imgFile = fc.getSelectedFile();
						try {
							img = ImageIO.read(imgFile);
						} catch (IOException e1) {
						}
    					shape = "image";
    				} else img = null;
    				break;

    			case "save":
    				fc = new JFileChooser();
    				fc.setFileFilter(new FileNameExtensionFilter("image(*.jpg, *.png, *.jpeg)", "jpg", "png", "jpeg"));
    				fc.setFileSelectionMode(JFileChooser.FILES_ONLY);
    				usrChoose = fc.showSaveDialog(null);
    				if (usrChoose==JFileChooser.APPROVE_OPTION) {
    					imgFile = fc.getSelectedFile();
    					try {
							BufferedImage imgSave =new Robot().createScreenCapture(
								new Rectangle(frame.getX()+10,
									frame.getY()+135,
									frame.jpDrawZone.getWidth()-5,
									frame.jpDrawZone.getHeight()-5));
    						
    						ImageIO.write(imgSave, "jpg", imgFile);	
    					} catch (IOException err) {
    					} catch (AWTException err) {
    					}
    				}
    				break;
    				
    			case "undo":
    				if (!frame.imgStore.isEmpty()) {
						frame.imgStore.remove(frame.imgStore.size()-1);
						frame.paint(frame.g); //重绘
    				}
    				break;
    			case "clear": //不可撤销的操作
    				frame.imgStore.clear();
    				frame.repaint();
    				break;
    				
    				
    			case "宋体":
    			case "黑体":
    			case "微软雅黑":
    				fontName=whichItem;
    				break;
    				
    			case "plain":
    				fontStyle=0;
    				break;
    			case "bold":
    				fontStyle=1;
    				break;
    			case "italic":
    				fontStyle=2;
    				break;
    			default: break;
			}
	}

	@Override
	public void mouseDragged(MouseEvent e) {
		Dimension size = frame.getContentPane().getSize();
		int curX=e.getX(), curY=e.getY(), tp=3;

		if (curX>10 && curY>140 && curX<size.width && curY<size.height+25) {
			switch(shape) {
			case "eraser":
			case "curve":
    			if (bx>10 && by>140 && bx<size.width && by<size.height+25) {
    				g.drawLine(bx, by, curX, curY);
					frame.imgStore.add(new Repaint(bx, by, curX, curY, gSize, currentColor, 0));
    			}
    			bx=curX; by=curY;
    			break;
			case "straight line": //0
				--tp;
			case "rectangle": //1
				--tp;
			case "circle": //2
				--tp;
			case "image": //3
				steadyDraw(tp, curX, curY);
				break;
				
			default: break;
			}
		} else {
			bx = curX;
			by = curY;
		}
	}
	
	private void steadyDraw(int tp, int curX, int curY) {
		boolean tmp;
		if (havePrint==false) {
				tmp = (tp==3 ? frame.imgStore.add(new Repaint(bx, by, curX, curY, img)):
					frame.imgStore.add(new Repaint(bx, by, curX, curY, gSize, currentColor, tp)));
				havePrint = true;
		} else {
				frame.imgStore.remove(frame.imgStore.size()-1); //移除原来的对象
				// 添加新位置的对象
				tmp = (tp==3 ? frame.imgStore.add(new Repaint(bx, by, curX, curY, img)):
					frame.imgStore.add(new Repaint(bx, by, curX, curY, gSize, currentColor, tp)));
		}
		frame.repaint();
	}

	@Override
	public void mouseMoved(MouseEvent e) {
	}

	@Override
	public void mouseClicked(MouseEvent e) {
	}

	@Override
	public void mousePressed(MouseEvent e) {
		bx = e.getX();
        by = e.getY();
        ox=bx; oy=by;

		// 获取线条粗细
		String _gSize = frame.gSizeDisplay.getText();
		boolean isText = shape.equals("text");
		try {
			int tmpSize = Integer.parseInt(_gSize);

			if (isText && tmpSize>=20)
				textSize = tmpSize;
			else if (!isText && tmpSize>=1)
				gSize=tmpSize;
		} catch(NumberFormatException err) {
		} finally {
			frame.gSizeDisplay.setText(isText?textSize.toString():gSize.toString());
		}
		if(!isText) g.setStroke(new BasicStroke(gSize));
	}

	@Override
	public void mouseReleased(MouseEvent e) {
    	ex = e.getX();
        ey = e.getY();
        
        switch(shape) {
        	case "straight line":
        	case "rectangle":
        	case "circle":
        	case "image":
        		havePrint = false;
                break;

        	case "text":
        		g.setFont(new Font(fontName, fontStyle, textSize));
                g.drawString(frame.inputText.getText(), bx, by);
        		frame.imgStore.add(new Repaint(bx, by, textSize, currentColor, fontName, fontStyle,
        				frame.inputText.getText()));
                break;
                
        	default:break;
		}
	}

	@Override
	public void mouseEntered(MouseEvent e) {
	}

	@Override
	public void mouseExited(MouseEvent e) {
	}
}

Repaint.java:61行代码

package repaint;

import java.awt.Color;
import java.awt.Image;

public class Repaint {
	//"straight line"0("curve"0), "rectangle"1,"circle"2,"text"3, "image"4, "eraser"0
	public int pattern; // 0->...
	public int gSize;
	//"black", "red", "green", "blue"
	public Color gColor;
	//宋体、微软雅黑、黑体
	public String fontName;
	//plain, italic, bold
	public int fontStyle;
	// image file
	public Image imgFile;
	// text
	public String text;
	
	public int bx, by, ex, ey;
	
	
	// straight line, curve
	public Repaint(int bx, int by, int ex, int ey, int gSize, Color gColor, int pattern) {
		this.bx=bx;
		this.by=by;
		this.ex=ex;
		this.ey=ey;
		this.gSize=gSize;
		this.gColor=gColor;
		
		this.pattern=pattern;
	}
	
	// text
	public Repaint(int bx, int by, int gSize, Color gColor, String fontName, int fontStyle, String text) {
		this.bx=bx;
		this.by=by;
		this.gSize=gSize;
		this.gColor=gColor;
		this.fontName=fontName;
		this.fontStyle=fontStyle;
		this.text=text;

		this.pattern=3;
	}
	
	// image
	public Repaint(int bx, int by, int ex, int ey, Image imgFile) {
		this.bx=bx;
		this.by=by;
		this.ex=ex;
		this.ey=ey;
		
		this.imgFile=imgFile;
		this.pattern=4;
	}
	
}

正常运行无任何报错，但是仍有许多不足之处，望批评指正。

qq_45849888
关注
专栏目录
Java绘图板源码 画图源代码 Swing
01-18
Java绘图板源代码 画图 使用Swing、LookAndFeel 支持图片打开保存，直线圆形椭圆矩形正方形多边形添加文字 菜单栏+右键菜单 Java程序设计课程设计
java 画图板源代码_非常值得学习的java 绘图板源代码
weixin_33524659的博客
02-16 1149
package minidrawpad;import java.awt.BasicStroke;import java.awt.Color;import java.awt.Font;import java.awt.Graphics2D;import java.io.Serializable;//图形绘制类 用于绘制各种图形//父类，基本图形单元，用到串行的接口，保存使用到//公共的属性放到超类中，...
如何用java实现一个画图面板（第一部分）
最新发布
zgx987321的博客
08-16 366
到这里这个最最简单的画图面板就完成了，然而，这个画图面板还有很多问题，比如在缩放窗体后，画板上的东西会消失不见。我会在下一篇博客详细介绍。创作理由：作为初学者，这个项目包含了动作监听器，窗体的创建，创建面板对象，类的继承等重要知识点，有助于初学者提升代码能力。然后是创建按钮，由于我要实现的是画直线和矩形还有改变颜色的功能，所以我创建了三个按钮，并命名为不同的名字。画图面板的设计方案是在鼠标按下时开始画线，鼠标松开时结束画图。首先，创建一个类，在这个类中，我们将要完成窗体的创建和画图面板对象的定义。
很值得学习的java 画图板源码
weixin_34292924的博客
06-09 458
很值得学习的java 画图板源码下载地址：http://download.csdn.net/source/2371150 package minidrawpad; import java.awt.*; import java.awt.event.*; import java.io.InputStreamReader; import java.io.Reader; import ...
java 画图板源代码_很值得学习的java 画图板源码
weixin_39997695的博客
02-16 1393
package minidrawpad;import java.awt.*;import java.awt.event.*;import java.io.InputStreamReader;import java.io.Reader;import javax.swing.*;// 主界面类public class DrawPad extends JFrame implements ActionLi...
java实现简易画图板源码
05-11
这是用java实现的一个简易画图板的源码，提供给需要的朋友。
Java 画板设计分析与实现[源码][附图]
07-28
4. **源码分析**： - 查看提供的源码，理解`paint()`方法中的逻辑，如何根据坐标和颜色绘制图形。 - 分析`update(Graphics g)`方法，了解它是如何更新屏幕的，以及何时调用`repaint()`方法触发重绘。 5. **性能...
java设计模式绘图画板课程设计源码带sql数据库脚本.zip
03-08
java设计模式绘图画板课程设计源码带sql数据库脚本.zip 带SQL数据库脚本 简单工厂模式、界面、桥接模式、装饰模式 java设计模式绘图画板课程设计源码带sql数据库脚本.zip 带SQL数据库脚本 简单工厂模式、界面、桥接...
Java课程设计-JavaSwing实现GUI画板课程设计源码
02-14
该画板中可以绘制的图形包括圆形（含椭圆）、矩形（含正方形）、直线和点，每个图形都需要保存位置、大小几何属性及是否填充、填充颜色、是否绘制边框和边框颜色等必要属性，用户通过选择按钮或者菜单项选中要绘制的...
Java免费学之画板入门源码和视频
08-28
前言：画板小程序是对之前Java中的类，继承，方法重载以及接口等知识的综合应用； 建议大家先去把相关知识看一下 思路： 1.创建窗体 2.在窗体上安装鼠标监听器，对鼠标动作进行监听； 3.拿到鼠标在窗体上按下...
Java画图板源代码
05-19
这是java实现的xp画图板的源代码，提供给需要的朋友
Java画图板程序 源代码
11-16
用Java实现类似于windows自带的画图板程序，麻雀虽小，五脏俱全哦！
简单画板（源代码）
11-07
简单画板（源代码）有有橡皮筋功能，文本输入功能，文件输入保存功能，调色功能，取色功能等等 用MFC实现
java画图板程序代码
10-14
安装NETBeans IDE7.3.1和JavaJDK5.0以上版本，然后新建项目,复制代码，运行即可得到绘图板。
Java实现画板（Java小程序 模仿Win系统画板）
05-20
Java小程序——模仿Win系统画板 使用Java实现Windows操作系统的高仿小画板。
Windows画板实例源码
11-11
Windows画板实例源码，绝对可完美运行，带有文字注释，欢迎下载！！！
java画板的设计和创建
马一凡的博客
10-28 404
首先创建一个画板类继承容器类，这样可以在画板类中重写容器的paint方法。 public class DrawFrame extends JPanel 再创建一个类写监听器的程序，以及一个类来写画板的内容对象参数保存的方法（可以在最小化以及伸缩窗口的时候使画面内容得到恢复） public class DrawMouse implements MouseListener, ActionLi...
绘画板 java_非常值得学习的java 绘图板源代码
weixin_39755712的博客
02-27 378
Java 小小绘图板,各种图形的绘制和文字的写入，也可以调整文字画笔的粗细 。还可以保存图像，非常值得学习的java 绘图板源代码下载地址：具体下载目录在 /pub/2011/11/05/java 绘图板源代码/用到的各种图片 请将图片放在icon文件夹下circle.jpgcolor.jpgfcircle.jpgfoval.jpgfrect.jpgfroundrect.jpgline.jpg...
java 画图板程序_JAVA做WINDOWS画图板的源程序？
weixin_34363835的博客
02-19 430
展开全部楼上的代码我做了一点点改正，我想现在可以正常运行了：//#8.15//#filename: ShapeMain.javaimport java.awt.BorderLayout;import java.awt.Button;import java.awt.Color;import java.awt.Container;import java.awt.Graphics;import java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值