精华内容
下载资源
问答
  • JAVA画板实验报告

    2019-04-18 17:53:44
    利用JAVA编写简易画板的实验报告,能实现基本图形绘制、添加文字、颜色更改等功能
  • Java画板实验报告.doc

    2020-08-09 00:10:34
    Java画板的设计 一实验名称及其要求 A实验名称Java画板的设计 B实验要求 1.实验目的图形界面设计 熟悉java.awt包中的组件掌握图形界面设计方法理解委托事件处理模型 2.实验要求 1设计图形界面添加菜单窗口上添加...
  • java画板(1

    2016-10-25 23:39:12
    缓冲(1) 书记袁(1) 击右侧我的(1) java笑脸(1) java浏览器(1) 记事本(1) java画板(1) java画图(1) 打字游戏(1) 围棋(1) 五子棋(1) java连连看(1) java无色连珠游戏源代码(1) 货币转换(1) 薄饼游戏源代码(1) java电话...
  • Java小程序——模仿Win系统画板 使用Java实现Windows操作系统的高仿小画板
  • NULL 博文链接:https://smallsmile.iteye.com/blog/779355
  • 画画_java画板_源码

    2021-10-01 07:45:25
    java画板,适合新手练习,更熟悉面对对象
  • 画板构成及架构方式1.1 构成1.2 架构方式2.一个优化2.1 窗口重绘机制2.2 引发的问题2.3 优化3.知识点梳理4.源代码4.1 runtime environment4.2 source code 完整源代码放在最后 1.画板构成及架构方式 1.1 构成 首先来...


    完整源代码放在最后

    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;
    	}
    	
    }
    
    

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

    展开全文
  • 一个简单的 Java 画板。 仅用于学习 java GUI 和 java 2d。 -- 基本功能: 画线,圆,矩形,文字! 改变目标的颜色 改变目标的位置! 改变目标的大小 将图像另存为文件并加载图像文件所有更改过程都是可见的。
  • 前言:画板小程序是对之前Java中的类,继承,方法重载以及接口等知识的综合应用; 建议大家先去把相关知识看一下 思路: 1.创建窗体 2.在窗体上安装鼠标监听器,对鼠标动作进行监听; 3.拿到鼠标在窗体上按下...
  • Java实现简单的画板

    2018-04-10 21:16:56
    Java实现的图形界面的简易画板程序,能够话出一般常见的形状
  • java画板demo

    2012-11-19 14:48:59
    使用java 写的一个简单的swing程序 画板 课程作业
  • java画板带实验报告

    2016-06-15 21:54:40
    java 画板 带实验报告. 有源代码
  • java画板的设计和创建

    2018-10-28 12:19:00
    首先创建一个画板类继承容器类,这样可以在画板类中重写容器的paint方法。 public class DrawFrame extends JPanel 再创建一个类写监听器的程序,以及一个类来写画板的内容对象参数保存的方法(可以在最小化以及...

    首先创建一个画板类继承容器类,这样可以在画板类中重写容器的paint方法。

    public class DrawFrame extends JPanel

    再创建一个类写监听器的程序,以及一个类来写画板的内容对象参数保存的方法(可以在最小化以及伸缩窗口的时候使画面内容得到恢复)

    public class DrawMouse implements MouseListener, ActionListener,MouseMotionListener 
    public class Shape

    我们可以看到我们会用到鼠标监听器,动作监听器,以及鼠标动作监听器。

    我们先简单地介绍一下他们的作用:

    1.鼠标监听器可以对于点击,按下,释放等事件做出响应,响应具体内容由程序员自己定义,发生相应的行为时即会触发对应方法,由此可见,监听器的作用很大,可以实现无限的可能。

    2.动作监听器我们目前用于响应对按钮的点击事件,读取按钮上的名称或者颜色信息来实现相应的方法。

    3鼠标动作监听器可以实现对鼠标进入界面,离开界面,界面内拖拽等功能的实现,极大丰富了界面特殊功能的实现。

    接下来进入主程序,主程序很简单,只是一个窗体构造方法的调用。

    public static void main(String[] args) {
                DrawFrame frame = new DrawFrame();
                frame.showUI();
            }
                javax.swing.JFrame jf = new javax.swing.JFrame();
                jf.setSize(800, 800);
                jf.getContentPane().setBackground(Color.WHITE);//设置背景色
                jf.setTitle("画板1.0");
                jf.setDefaultCloseOperation(3);
                // 设置居中显示
                jf.setLocationRelativeTo(null)            
                DrawMouse mouse = new DrawMouse();
                jf.setLayout(new BorderLayout());            
                JPanel jp1= new JPanel();
                jp1.setBackground(Color.green);
                jf.add(jp1,BorderLayout.NORTH);

    在showUI里先是对一些基本组件的添加和创建,这里就不再一一赘述。值得一提的是其中容器的添加以及边框布局的规则。jf就是一个巨大的容器对象,一般来说,如果我们不定义流式布局,便会默认边框布局。边框布局可以把区域划分为5个部分,north,south,center,east,west。我们把按钮放在了上方,把画板主题部分放在中间,这样两个区域便互不干扰,是两个独立的容器。这些对象的父类便是JPanel类。

                this.setBackground(Color.WHITE);
                jf.add(this, BorderLayout.CENTER);

    使用this即可调用,默认以容器类来创建对象(容器可以创建多个对象)。

    String[] shape ={"直线","矩形","三角形","椭圆","任意边形","曲线","橡皮擦","迭代图像","递归"};
                for(int i=0;i<shape.length;i++){
                    JButton jbu = new JButton(shape[i]);
                    jp1.add(jbu);
                    jbu.addActionListener(mouse);
                }
                Color[] color = {Color.RED,Color.BLUE,Color.BLACK};
                for(int i=0;i<color.length;i++){
                    JButton jbu = new JButton();
                    jbu.setBackground(color[i]);
                    jbu.setPreferredSize(new Dimension(30, 30));
                    jp1.add(jbu);
                    jbu.addActionListener(mouse);
                }

    循环创建按钮可以在多按钮需求的时候剩下不少力气。循环创建按钮并为其添加动作监听器。

                jf.setVisible(true);            
                //获取画笔对象:图形画在那个组件上,画笔就从该组件上获取
                //从窗体上获取画笔对象            
                Graphics g = this.getGraphics();   
                //给窗体添加鼠标监听器方法
                this.addMouseListener(mouse);
                this.addMouseMotionListener(mouse);
                mouse.setGr(g);
                mouse.setArrayShape(arrayShape);

    窗体可视化并获取画笔对象后我们添加鼠标监听器。这里用到了传对象的方法,来使得在监听器的类中可以使用画笔和对象数组。对象数组的创建是为了保存每一个图画信息的坐标及颜色信息,便于复原。

        private Graphics gr;
        private int x1, y1, x2, y2, x3, y3;
        private double x;
        private double y;    
        private int xf,yf,xl,yl,x0,y0;
        private String name;
        private int flag=0;
        private int flagq=0;
        private int step=1;
        private int flag_line=0;
        private Color color = Color.black;
        private double a=-1.2;
        private double b=1.6;
        private double c=-1;
        private double d=-1.5;
        private int index=0;
        private Shape[] arrayShape;

    在监听器里定义了很多属性,这些属性在编程实现特殊功能的时候十分有用,可作为开关,可用于传递对象,可作为方法内的参数来调用等,这里不一一赘述。

        public void mouseClicked(MouseEvent e) {        
            if ("任意边形".equals(name)){
                if(flag==0)
                {
                    x0 = e.getX();
                    y0 = e.getY();
                    xf = e.getX();
                    yf = e.getY();                
                    flag=1;
                }
                else
                {
                    xl = e.getX();
                    yl = e.getY();
                    gr.drawLine(xf, yf, xl, yl);
                    set_shape(xf, yf, xl, yl,"直线",color);
                    xf=xl;
                    yf=yl;
                    if(e.getClickCount()==2)
                    {
                        flag=0;
                        gr.drawLine(x0, y0, xl, yl);
                        set_shape(x0, y0, xl, yl,"直线",color);
                    }
                }          
            }
            if("三角形".equals(name)){
                System.out.println(step); 
                   switch(step)
                   {
                   case 1:
                       x1=e.getX();
                       y1=e.getY();
                       step++;
                       break;
                   case 2:
                       x2=e.getX();
                       y2=e.getY();
                       gr.drawLine(x1, y1, x2, y2);
                       step++;
                       break;
                   case 3:
                       x3=e.getX();
                       y3=e.getY();
                       set_shape(x1,y1,x2,y2,"直线",color);
                       set_shape(x2,y2,x3,y3,"直线",color);
                       set_shape(x1,y1,x3,y3,"直线",color);
                       step=1;
                       gr.drawLine(x2, y2, x3, y3);
                       gr.drawLine(x1, y1, x3, y3);
                       break;           
                   default:;
                   }               
            }
            if("迭代图像".equals(name))
            {
                x=e.getX();
                y=e.getY();
                iterate(x,y); 
                //set_shape((int)x, (int)y, 0, 0,"迭代图像",color);
            }
            if("递归".equals(name))
            {
                  int xa=1+(int)(Math.random()*800);
                  int ya=1+(int)(Math.random()*800);
                  int xb=1+(int)(Math.random()*800);
                  int yb=1+(int)(Math.random()*800);
                  int xc=1+(int)(Math.random()*800);
                  int yc=1+(int)(Math.random()*800);
                  int xp=1+(int)(Math.random()*800);              
                  int yp=1+(int)(Math.random()*800);        
                  int turn=1;
                  System.out.println("xa"+xa+"ya"+ya+"xb"+xb+"yb"+yb+"xc"+xc+"yc"+yc+"xp"+xp+"yp"+yp);
                  for(int i=0;i<10000;i++)
                  {
                      turn=1+(int)(Math.random()*3);
                      switch(turn)
                      {
                      case 1:                      
                          xp=(xa+xp)/2;
                          yp=(ya+yp)/2;
                          gr.drawLine(xp, yp, xp, yp);
                          break;
                      case 2:                      
                          xp=(xb+xp)/2;
                          yp=(yb+yp)/2;
                          gr.drawLine(xp, yp, xp, yp);                      
                          break;
                      case 3:                      
                          xp=(xc+xp)/2;
                          yp=(yc+yp)/2;
                          gr.drawLine(xp, yp, xp, yp);                  
                          break    ;              
                      }                                
                  }            
            }
        }

    在click事件里获取坐标值,再判断当前name类型,实现画三角形和画任意边形等操作。click 双击还可自动补全缺线,结束多边形的绘制。因为鼠标事件的实现非常复杂,且与按下,释放联系紧密,单独介绍不便于一一解释,我们就提一些有趣的想法,然后剩下的就留读者思考和设计创造了。

    public void mousePressed(MouseEvent e) {
            System.out.println("按下");
            if("矩形".equals(name)||"椭圆".equals(name))
            {
            x1 = e.getX();
            y1 = e.getY();
            }
            //System.out.println(name);
            if ("曲线".equals(name))
            {
                flagq=1;
                //System.out.println(flagq);
                xf=e.getX();
                yf=e.getY();
            }
            if("直线".equals(name))
            {
                x0=e.getX();
                y0=e.getY();            
                x1=e.getX();
                y1=e.getY();           
                flag_line=1;            
            }
        }
        public void mouseReleased(MouseEvent e) {
            System.out.println("释放");
            
            if("矩形".equals(name)||"椭圆".equals(name))
            {
            x2 = e.getX();
            y2 = e.getY();
            }
            /*if ("直线".equals(name)) {
                // 画线
                gr.drawLine(x1, y1, x2, y2);
            }*/
            if ("矩形".equals(name)) {
                gr.drawRect(Math.min(x1, x2), Math.min(y1, y2), Math.abs(x1 - x2), Math.abs(y1 - y2));
                set_shape(Math.min(x1, x2), Math.min(y1, y2), Math.abs(x1 - x2), Math.abs(y1 - y2),"矩形",color);            
            }
            if("椭圆".equals(name)){
                gr.drawOval(Math.min(x1, x2),Math.min(y1, y2), Math.abs(x1-x2),Math.abs(y1-y2));
                set_shape(Math.min(x1, x2),Math.min(y1, y2), Math.abs(x1-x2),Math.abs(y1-y2),"椭圆",color);            
            }
            if ("曲线".equals(name))
            {
                flagq=0;
                System.out.println(flagq);
            }
            if("直线".equals(name))
            {
                flag_line=0;
                set_shape(x0,y0,x2,y2,"直线",color);
            }      
          }

    按下和释放可以获取两个坐标,可以轻松地画出直线,矩形等形状,三角形和多边形的实现用到了click事件(这里关于x1,y1,x2,y2,x3,y3变量的使用十分巧妙,可以作为前一个点,和后一个点来理解,实现连续画多线)。

        public void actionPerformed(ActionEvent e) {              
            if("".equals(e.getActionCommand())){
                //获取当前事件源
                JButton jbu = (JButton)e.getSource();
                //获取按钮的背景色
                color = jbu.getBackground();
                //设置画笔颜色
                gr.setColor(color);
            }else{
                // 获取按钮内容
                name = e.getActionCommand();
            }        
            System.out.println("name = " + name);
        }

    按钮功能的实现代码贴出。

       public void mouseDragged(MouseEvent e)
        {
            //System.out.print("x坐标:"+e.getX()+"  y坐标:"+e.getY());
            if (flagq==1)
            {
                xl=e.getX();
                yl=e.getY();
                gr.drawLine(xf, yf, xl, yl);
                set_shape(xf, yf, xl, yl,"直线",color);
                xf=xl;
                yf=yl;
            }
            if("橡皮擦".equals(name))
            {
                x1=e.getX();
                y1=e.getY(); 
                gr.setColor(Color.white);
                gr.fillRect(x1-5, y1-5, 10, 10);
                gr.setColor(color); 
                //gr.clearRect(x1-5, y1-5, 10, 10);
                set_shape(x1-5, y1-5, 10, 10,"橡皮擦",color);          
            }
            if("直线".equals(name)&&flag_line==1)
            {
                x2=e.getX();
                y2=e.getY();
                gr.setColor(Color.white);
                gr.drawLine(x0, y0, x1, y1);                    
                gr.setColor(color);                      
                gr.drawLine(x0, y0, x2, y2);            
                x1=x2;
                y1=y2;            
            }      
        }

    这段代码有两个地方很有意思,一个是直线的绘制。我最初使用的是press和release,这样在鼠标拖动的过程中直线是不可见的,我们把其在鼠标拖动事件中实现,及在按下的时候保存坐标初值,然后不断获取鼠标位置,画新的线,用背景色覆盖原先的线,实现直线的实时显示。还有一个就是画曲线,及不断保存前后点的坐标,画很多短线,实现曲线的效果。

     private Shape[] arrayShape=new Shape[9000];
        public void set_shape(int x1,int y1,int x2,int y2,String name,Color color)
        {        
            Shape shape=new Shape(x1,y1,x2,y2,name,color);                         
            arrayShape[index++] = shape;       
        }

    关于图像的复原,我们的思路是把每一步设置为对象保存在shape中,然后当最小化再打开,或者拖拽窗体时,再调用这个数组取出其中的内容,实现画面的恢复。

         public Shape(int x1,int y1,int x2,int y2,String name,Color color)
         {
             this.x1=x1;
             this.y1=y1;
             this.x2=x2;
             this.y2=y2;
             this.name=name;
             this.color=color;
         }
        
         public void drawShape(Graphics g)
         {
             switch(name)
             {
             case "直线":
                 g.setColor(color);
                 g.drawLine(x1, y1, x2, y2);
                // System.out.println("画");
                 break;
             case "矩形":
                 g.setColor(color);
                 g.drawRect(x1, y1, x2, y2);
                 break;
             case "椭圆":
                 g.setColor(color);
                 g.drawOval(x1, y1, x2, y2);
                 break;        
             case "橡皮擦":
                 g.setColor(color);
                 g.clearRect(x1, y1, x2, y2);
                 break;         
             }
            public void paint(Graphics g)
            {
                super.paint(g);           
                for(int i=0;i<arrayShape.length;i++)
                {
                    Shape shape=arrayShape[i];
                    if(shape!= null)
                        shape.drawShape(g);
                    else break;
                }           
            }

    这是涉及到参数保存和取出的方法。

    以上代码便实现了我们的画板了,以画板为基础我们接下来还可以实现很多界面的设计,在画板的学习过程中充分使用了监听器这个工具,程序的可设计性大大提高了。

     

    展开全文
  • JAVA画板(改进版)

    2010-01-01 20:56:46
    画板是在前有花瓣的基础上添加了许多功能后形成的一个功能比较强大的而且代码简单的JAVA程序,适合初学者使用。
  • Java画图画板完整代码

    2019-03-07 17:44:08
    画板完成了画长方形、正方形、椭圆、自由作画,并且可以实现填充作画以及颜色调换。上传代码完整,下载即可使用。
  • 课程设计报告JAVA画板模拟画图工具.doc
  • java画板

    2012-02-27 23:19:20
    创建java画板   画板的实现步骤 a.定义一个画板类,让该类继承自JFrame   b.定义一个初始化界面的方法,方法中要初始化JFrame的属性   c.给窗体设置菜单栏的方法   d.创建一个窗体的工具面板类,...

    创建java画板

     

    画板的实现步骤

    a.定义一个画板类,让该类继承自JFrame

     

    b.定义一个初始化界面的方法,方法中要初始化JFrame的属性

     

    c.给窗体设置菜单栏的方法

     

    d.创建一个窗体的工具面板类,然后将该类添加到窗体上的左侧

    给工具面板上的每一个功能按钮添加动作监听器,并且绑定事件

    处理类对象。

     

    e.创建一个颜色的面板类,然后将该类添加到窗体上的底部

    要给窗体添加颜色的按钮或者标签,并且绑定事件处理对象。

     

    f.创建一个画图形的面板类,然后将对象添加到窗体的中间。

    1.将事件添加到面板类里边。

    2.在画板类中给画图形的面板类添加监听器,并且绑定事件处理

    类对象


     

     

     

    1.建立程序入口(main函数)

       public class Main {

    	public static void main(String[] args) {
    		DrawFrame f = new DrawFrame();
    		f.pack();
    		f.setVisible(true);
    		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    	}
    }
     

        也可以在主函数将画板布局

        public class PanelFrame extends JFrame{

    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
               PanelFrame drawPanel=new PanelFrame();
               drawPanel.showUI();
    	}
    	
    	//创建界面
    	public void showUI(){
    		   this.setTitle("Draw_Panel");
    		   this.setSize(700,600);
    		   this.setDefaultCloseOperation(3);
    		   this.setResizable(false);
    		   this.setLocationRelativeTo(null);
    		   
    		   this.setLayout(new BorderLayout());
    		   
    		   MenuPanel menuPanel=new MenuPanel();
    		   this.setJMenuBar(menuPanel.createMenu());
    		   //menuPanel.createMenu();
    		   this.add(menuPanel,BorderLayout.NORTH);
    		   
    		   ToolPanel toolPanel=new ToolPanel();
    		   this.add(toolPanel,BorderLayout.WEST);
    		   
    		   DrawPanel drawPanel=new DrawPanel();
    		   this.add(drawPanel,BorderLayout.CENTER);
    		   
    		   ColorPanel colorPanel=new ColorPanel();
    		   this.add(colorPanel,BorderLayout.SOUTH);
    		   
    		   Graphics g=drawPanel.getGraphics();
    		   
    		   this.setVisible(true);
    	}
    
    	
    
    }

     

        在主函数中定义了画板的题目、大小等界面的性质,同时也为面板加上布局管理器——边缘布局,分别加上菜单面板、       工具面板和颜色面板,并定义一个画布,最后设置画板可见。

     

     

    2.布局整个面板

       public class DrawFrame extends JFrame {

              // 设置默认画板
    	private JPanel drawSpace = createDrawSpace();
    	// 设置缓冲图片
    	private MyImage bufferedImage = new MyImage(
    			(int) screenSize.getWidth() / 2, (int) screenSize.getHeight() / 2,
    			BufferedImage.TYPE_INT_RGB);
    	// 设置当前使用的工具
    	private Tool tool = null;
    	// 设置画图对象
    	Graphics g = bufferedImage.getGraphics();
    	// 颜色显示面板
    	private JPanel currentColorPanel =  new JPanel();;
    	// 颜色选择器
    	private JColorChooser colorChooser = getColorChooser();
    	// 加给菜单的事件监听器
    	ActionListener menuListener = new ActionListener() {
    		           public void actionPerformed(ActionEvent e) {
    			                   service.menuDo(DrawFrame.this, e.getActionCommand());
    		           }
    	};
    	// 默认JScrollPane
    	private JScrollPane scroll = null;
    	// 工具栏
    	JPanel toolPanel = createToolPanel();
    	// 颜色面板
    	JPanel colorPanel = createColorPanel();
    
            public DrawFrame() {
    		super();
    		// 初始化
    		init();
    	}
    
            public void init() {
    		// 设置标题
    		this.setTitle("未命名 - 画图");
    		// 初始化画图
    		service.initDrawSpace(this);
    		// 设置标题
    		// 获取正在使用的工具
    		tool = ToolFactory.getToolInstance(this, Tool.PENCIL_TOOL);
    
    		// 创建鼠标运动监听器
    		MouseMotionListener motionListener = new MouseMotionAdapter() {
    			// 拖动鼠标
    			public void mouseDragged(MouseEvent e) {
    				   tool.mouseDragged(e);
    			}
    
    			// 移动鼠标
    			public void mouseMoved(MouseEvent e) {
    				   tool.mouseMoved(e);
    			}
    
    		};
    		// 创建鼠标监听器
    		MouseListener mouseListener = new MouseAdapter() {
    			// 松开鼠标
    			public void mouseReleased(MouseEvent e) {
    				tool.mouseReleased(e);
    			}
    
    			// 按下鼠标
    			public void mousePressed(MouseEvent e) {
    				tool.mousePressed(e);
    			}
    
    			// 点击鼠标
    			public void mouseClicked(MouseEvent e) {
    				tool.mouseClicked(e);
    			}
    		};
    
    		drawSpace.addMouseMotionListener(motionListener);
    		drawSpace.addMouseListener(mouseListener);
    
    		createMenuBar();
    		
    		// 以drawSpace为viewport去创建一个JScrollPane
    		/*
    		 * public class JScrollPane extends JComponent implements ScrollPaneConstants, Accessible{
    		 *        protected JViewport viewport;
    		 *        protected JScrollBar verticalScrollBar;
    		 * }
             */
    		scroll = new JScrollPane(drawSpace);
    		// 设置viewport
    		DrawService.setViewport(scroll, drawSpace, bufferedImage.getWidth(),
    				bufferedImage.getHeight());
    		// 将panel加到本Frame上面
    		this.add(scroll, BorderLayout.CENTER);
    		this.add(toolPanel, BorderLayout.WEST);
    		this.add(colorPanel, BorderLayout.SOUTH);
    	}
    
    	/*
    	 * 获取画布
    	 */
    	public JPanel getDrawSpace() {
    		   return this.drawSpace;
    	}
    
    	/*
    	 * 获取JScroolPane
    	 */
    	public JScrollPane getScroll() {
    		   return this.scroll;
    	}
    
    	/*
    	 * 获取工具栏
    	 */
    	public JPanel getToolPanel() {
    		   return this.toolPanel;
    	}
    
    	/*
    	 * 获取颜色面板
    	 */
    	public JPanel getColorPanel() {
    		   return this.colorPanel;
    	}
    
    	/*
    	 * 获取图片
    	 */
    	public MyImage getBufferedImage() {
    		   return this.bufferedImage;
    	}
    
    	/*
    	 * 设置图片
    	 */
    	public void setBufferedImage(MyImage bufferedImage) {
    		   this.bufferedImage = bufferedImage;
    	}
    
    	/*
    	 * 设置工具
    	 */
    	public void setTool(Tool tool) {
    		   this.tool = tool;
    	}
    
    	/*
    	 * 获取工具
    	 */
    	public Tool getTool() {
    		   return this.tool;
    	}
    
    	/*
    	 * 获取颜色选择器
    	 */
    	public JColorChooser getColorChooser() {
    		   if (colorChooser == null) {
    			   colorChooser = new JColorChooser();
    		   }
    		   return colorChooser;
    	}
    
    	/*
    	 * 创建简单颜色选择板
    	 */
    	public JPanel createColorPanel() {
    		   JPanel panel = new ColorPanel(currentColorPanel);
    		   // 返回
    		   return panel;
    	}
    
    	/*
    	 * 获取颜色显示面板
    	 */
    	public JPanel getCurrentColorPanel() {
    		   return this.currentColorPanel;
    	}
    
            /*
    	 * 创建菜单栏
    	 */
    	public void createMenuBar() {
    		// 创建一个JMenuBar放置菜单
    		JMenuBar menuBar = new JMenuBar();
    		// 菜单文字数组,与下面的menuItemArr一一对应
    		String[] menuArr = { "文件(F)", "查看(V)", "颜色(C)", "帮助(H)" };
    		// 菜单项文字数组
    		String[][] menuItemArr = { { "新建(N)", "打开(O)", "保存(S)", "-", "退出(X)" },
    				{ "工具箱(T)", "颜料盒(C)" }, { "编辑颜色" }, { "帮助主题", "关于" } };
    		// 遍历menuArr与menuItemArr去创建菜单
    		for (int i = 0; i < menuArr.length; i++) {
    			// 新建一个JMenu菜单
    			JMenu menu = new JMenu(menuArr[i]);
    			for (int j = 0; j < menuItemArr[i].length; j++) {
    				// 如果menuItemArr[i][j]等于"-"
    				if (menuItemArr[i][j].equals("-")) {
    					// 设置菜单分隔
    					menu.addSeparator();
    				} else {
    					// 新建一个JMenuItem菜单项
    					JMenuItem menuItem = new JMenuItem(menuItemArr[i][j]);
    					menuItem.addActionListener(menuListener);
    					// 把菜单项加到JMenu菜单里面
    					menu.add(menuItem);
    				}
    			}
    			// 把菜单加到JMenuBar上
    			menuBar.add(menu);
    		}
    		// 设置JMenubar
    		this.setJMenuBar(menuBar);
    	}
    
    	/*
    	 * 创建画板
    	 */
    	public JPanel createDrawSpace() {
    		JPanel drawSpace = new DrawSpace();
    		// 设置drawSpace的大小
    		drawSpace.setPreferredSize(new Dimension((int) screenSize.getWidth(),
    				(int) screenSize.getHeight() - 150));
    		return drawSpace;
    	}
    
    	/*
    	 * 创建工具栏
    	 */
    	public JPanel createToolPanel() {
    		JPanel panel = new ToolPanel(this);
    		// 返回
    		return panel;
    	}
    
    	// 画图区域
    	public class DrawSpace extends JPanel {
    		/*
    		 * 重写void paint( Graphics g )方法
    		 */
    		public void paint(Graphics g) {
    			service.repaint(g, bufferedImage);
    		}
    	}
    }

     

        当然,也可以单独设计菜单类

        public class MenuPanel extends JPanel{

           
    	    private JMenuBar menuBar=new JMenuBar();
    	   
    	    private String[] arrayMenu={"文件","颜色","帮助"};
    	    private String[][] arrayMenuItem={{"新建","保存","-","退出"},
    			                     {"编辑颜色"},
    			                     {"帮助主题","关于帮助"}};
    	   
    	    public JMenuBar createMenu(){
    	          for(int i=0;i<arrayMenu.length;i++){
    		          JMenu menu=new JMenu();
    		          for(int j=0;j<arrayMenuItem[i].length;j++){
    			          JMenuItem menuItem=new JMenuItem();
    			          if(!arrayMenuItem[i][j].equals("-")){
    				         menu.add(menuItem);
    			          }
    			          else{
    				          menu.addSeparator();
    			          }
    		          }
    		          menuBar.add(menu);
    	          }
    	          
    	          return menuBar;
    	    }
    	
    }

     

        这里要实现菜单栏要注意首先要创建JMenuBar,这相当于一个菜单面板,再创建JMenu类的一维数组,并将其加在         JMenuBar上,这相当于菜单面板上的按钮,然后创建一个JMenuItem类型的二维数组,即相当于菜单按钮上的下拉选     项。JMenuItem加在JMenu上。

        创建数组要注明数组长度,二维数组则必须指定第一维的长度,如String array[size]=new String array[];

        String array2[size][]=new String array2[][]; 或者在创建数组的时候就将其赋值,则不用指定数组长度。

     

    3.设置工具面板类

       public class ToolPanel extends JPanel {

    	// 在构造函数中初始化该面板
    	public ToolPanel(DrawFrame df) {
    		// 创建一个标题为"工具"的工具栏
    		JToolBar toolBar = new JToolBar("工具");
    		// 设置为垂直排列
    		toolBar.setOrientation(toolBar.VERTICAL);
    		// 设置为可以拖动
    		toolBar.setFloatable(true);
    		// 设置与边界的距离
    		toolBar.setMargin(new Insets(2, 2, 2, 2));
    		// 设置布局方式
    		toolBar.setLayout(new GridLayout(5, 2, 2, 2));
    		// 工具数组
    		String[] toolarr = {
    
                                            "atomizercursor","AtomizerTool","brushcursor","BrushTool",
    		                       "colorcursor","ColorPickedTool","erasercursor","EraserTool",
    		                       "LineTool","pencilcursor","PencilTool","PolygonTool","RectTool",
    		                       "RoundRectTool","RoundTool"
    }; for (int i = 0; i < toolarr.length; i++) { ImageAction action = new ImageAction(new ImageIcon("img/" + toolarr[i] + ".jpg"), toolarr[i], df); // 以图标创建一个新的button JButton button = new JButton(action); // 把button加到工具栏中 toolBar.add(button); } this.add(toolBar); } }  

       或者将数组等一些变量设置成功能面板的属性

        public class ToolPanel extends JPanel{

    	   
    	   private JPanel panel=new JPanel();
          
           private String[] array={"atomizercursor","AtomizerTool","brushcursor","BrushTool",
    		                       "colorcursor","ColorPickedTool","erasercursor","EraserTool",
    		                       "LineTool","pencilcursor","PencilTool","PolygonTool","RectTool",
    		                       "RoundRectTool","RoundTool"};
        	      
           public void show_toolPanel(){
        	             panel.setPreferredSize(new Dimension(60,300));
        	             panel.setLayout(new GridLayout(5,2,2,2));
        	             
        	             
        	             public String getArray(){
              	    	        int i;
              	    	        if(i>=0&&i<array.length){
              	    		       return array[i];
              	    	        }
              	    	        
              	    	        return null;
        	             }
        	             
        	             
        	             for(int i=0;i<array.length;i++){
        	            	 ImageIcon image=new ImageIcon("img/"+array[i]+".jpg");
        	            	 JButton button=new JButton(image);
        	            	 button.setSize(new Dimension(16,16));
        	            	 this.add(button);
        	             }
        	             
        	             this.setLayout(new FlowLayout());
        	             this.add(panel);
        	      
    	   }             
        	       
        	   
    
    
    }             
     

        将功能面板上的组件装入一个数组,再创建ImageIcon类将数组元素转换成在同一个java project下的组件图片,并将     每一个图片显示在按钮上,因为功能面板是设置成网格布局,panel.setLayout(new GridLayout(5,2,2,2));

     

    4.功能面板上功能的实现

       创建一个抽象工具类,定义所有画图工具所需的属性和方法

       public abstract class AbstractTool implements Tool {

    	// 定义ImageFrame
    	private DrawFrame frame = null;
    	// 定义画板的宽
    	public static int drawWidth = 0;
    	// 定义画板的高
    	public static int drawHeight = 0;
    	// 定义默认鼠标指针
    	private Cursor defaultCursor = new Cursor(Cursor.DEFAULT_CURSOR);
    	// 按下鼠标的x坐标
    	private int pressX = -1;
    	// 按下鼠标的y坐标
    	private int pressY = -1;
    	// 颜色
    	public static Color color = Color.BLACK;
    
    	/*
    	 * 构造器
    	 */
    	public AbstractTool(DrawFrame frame) {
    		this.frame = frame;
    		AbstractTool.drawWidth = frame.getBufferedImage().getWidth();
    		AbstractTool.drawHeight = frame.getBufferedImage().getHeight();
    	}
    
    	public AbstractTool(DrawFrame frame, String path) {
    		this(frame);
    		// 创建工具鼠标图型
    		this.defaultCursor = DrawService.createCursor(path);
    	}
    
    	/*
    	 * 获取ImageFrame
    	 */
    	public DrawFrame getFrame() {
    		return this.frame;
    	}
    
    	/*
    	 * 获取默认鼠标指针 
    	 */
    	public Cursor getDefaultCursor() {
    		return this.defaultCursor;
    	}
    
    	/*
    	 * 设置默认鼠标指针
    	 */
    	public void setDefaultCursor(Cursor cursor) {
    		this.defaultCursor = cursor;
    	}
    
    	/*
    	 * 设置x坐标
    	 */
    	public void setPressX(int x) {
    		this.pressX = x;
    	}
    
    	/*
    	 * 设置y坐标
    	 */
    	public void setPressY(int y) {
    		this.pressY = y;
    	}
    
    	/*
    	 * 获取x坐标
    	 */
    	public int getPressX() {
    		return this.pressX;
    	}
    
    	/*
    	 * 获取y坐标
    	 */
    	public int getPressY() {
    		return this.pressY;
    	}
    
    	/*
    	 * 拖动鼠标
    	 */
    	public void mouseDragged(MouseEvent e) {
    		// 拖动图形边界
    		dragBorder(e);
    		// 画图
    		Graphics g = getFrame().getDrawSpace().getGraphics();
    		createShape(e, g);
    
    	}
    
    	/*
    	 * 移动鼠标
    	 * e MouseEvent
    	 */
    	public void mouseMoved(MouseEvent e) {
    		// 获取鼠标现在的x与y坐标
    		int x = e.getX();
    		int y = e.getY();
    		// 获取默认鼠标指针
    		Cursor cursor = getDefaultCursor();
    		// 如果鼠标指针在右下角
    		if (x > AbstractTool.drawWidth - 4 && x < AbstractTool.drawWidth + 4
    				&& y > AbstractTool.drawHeight - 4
    				&& y < AbstractTool.drawHeight + 4) {
    			// 将鼠标指针改变为右下拖动形状
    			cursor = new Cursor(Cursor.NW_RESIZE_CURSOR);
    		}
    		// 如果鼠标指针在右中
    		if (x > AbstractTool.drawWidth - 4 && x < AbstractTool.drawWidth + 4
    				&& y > (int) AbstractTool.drawHeight / 2 - 4
    				&& y < (int) AbstractTool.drawHeight / 2 + 4) {
    			// 将鼠标指针改变为右拖动形状
    			cursor = new Cursor(Cursor.W_RESIZE_CURSOR);
    		}
    		// 如果鼠标指针在下中
    		if (y > AbstractTool.drawHeight - 4 && y < AbstractTool.drawHeight + 4
    				&& x > (int) AbstractTool.drawWidth / 2 - 4
    				&& x < (int) AbstractTool.drawWidth / 2 + 4) {
    			// 将鼠标指针改变为下拖动形状
    			cursor = new Cursor(Cursor.S_RESIZE_CURSOR);
    		}
    		// 设置鼠标指针类型
    		getFrame().getDrawSpace().setCursor(cursor);
    	}
    
    	/*
    	 * 松开鼠标
    	 */
    	public void mouseReleased(MouseEvent e) {
    		// 画图
    		Graphics g = getFrame().getBufferedImage().getGraphics();
    		createShape(e, g);
    		// 把pressX与pressY设置为初始值
    		setPressX(-1);
    		setPressY(-1);
    		// 重绘
    		getFrame().getDrawSpace().repaint();
    	}
    
    	/*
    	 * 画图形
    	 */
    	private void createShape(MouseEvent e, Graphics g) {
    		    // 如果位置在画布内
    		    if (getPressX() > 0 && getPressY() > 0 && e.getX() > 0
    				   && e.getX() < AbstractTool.drawWidth && e.getY() > 0
    				   && e.getY() < AbstractTool.drawHeight) {
    			       // 将整张图片重画
    			       g.drawImage(getFrame().getBufferedImage(), 0, 0,
    					       AbstractTool.drawWidth, AbstractTool.drawHeight, null);
    			       // 设置颜色
    			       g.setColor(AbstractTool.color);
    			       getFrame().getBufferedImage().setIsSaved(false);
    			       // 画图形
    			       draw(g, getPressX(), getPressY(), e.getX(), e.getY());
    		    }
    	}
    
    	/*
    	 * 按下鼠标
    	 */
    	public void mousePressed(MouseEvent e) {
    		// 如果位置在图片范围内,设置按下的坐标
    		if (e.getX() > 0 && e.getX() < AbstractTool.drawWidth && e.getY() > 0
    				&& e.getY() < AbstractTool.drawHeight) {
    			setPressX(e.getX());
    			setPressY(e.getY());
    		}
    	}
    
    	/*
    	 * 点击鼠标
    	 */
    	public void mouseClicked(MouseEvent e) {
    	}
    
    	/*
    	 * 画图形
    	 */
    	public void draw(Graphics g, int x1, int y1, int x2, int y2) {
    	}
    
    	/*
    	 * 拖动图形边界
    	 */
    	private void dragBorder(MouseEvent e) {
    		//getFrame().getBufferedImage().setIsSaved(false);
    		// 获取鼠标现在的x与y坐标
    		int cursorType = getFrame().getDrawSpace().getCursor().getType();
    		int x = cursorType == Cursor.S_RESIZE_CURSOR ? AbstractTool.drawWidth
    				: e.getX();
    		int y = cursorType == Cursor.W_RESIZE_CURSOR ? AbstractTool.drawHeight
    				: e.getY();
    		MyImage img = null;
    		// 如果鼠标指针是拖动状态
    		if ((cursorType == Cursor.NW_RESIZE_CURSOR
    				|| cursorType == Cursor.W_RESIZE_CURSOR || cursorType == Cursor.S_RESIZE_CURSOR)
    				&& (x > 0 && y > 0)) {
    			// getFrame().getDrawSpace().setSize( x + 4, y + 4 );
    			// 改变图像大小
    			img = new MyImage(x, y, BufferedImage.TYPE_INT_RGB);
    			Graphics g = img.getGraphics();
    			g.setColor(Color.WHITE);
    			g.drawImage(getFrame().getBufferedImage(), 0, 0,
    					    AbstractTool.drawWidth, AbstractTool.drawHeight, null);
    			getFrame().setBufferedImage(img);
    			// 设置画布的大小
    			AbstractTool.drawWidth = x;
    			AbstractTool.drawHeight = y;
    			// 设置viewport
    			DrawService.setViewport(frame.getScroll(), frame.getDrawSpace(),
    					x, y);
    		}
    	}
    }
     

        a.画直线

           public class LineTool extends AbstractTool {

    	private static Tool tool = null;
    
    	private LineTool(DrawFrame frame) {
    		super(frame);
    	}
    
    	public static Tool getInstance(DrawFrame frame) {
    		if (tool == null) {
    			tool = new LineTool(frame);
    		}
    		return tool;
    	}
    
    	/*
    	 * 画图形
    	 */
    	public void draw(Graphics g, int x1, int y1, int x2, int y2) {
    		g.drawLine(x1, y1, x2, y2);
    	}
    }
     

       b.铅笔

       public class PencilTool extends AbstractTool {

    private static Tool tool = null;

     

    private PencilTool(DrawFrame frame) {

    super(frame, "img/pencilcursor.gif");

    }

     

    public static Tool getInstance(DrawFrame frame) {

    if (tool == null) {

    tool = new PencilTool(frame);

    }

    return tool;

    }

     

    /*

    * 拖动鼠标

    */

    public void mouseDragged(MouseEvent e) {

    super.mouseDragged(e);

    // 获取图片的Graphics对象

    Graphics g = getFrame().getBufferedImage().getGraphics();

    if (getPressX() > 0 && getPressY() > 0) {

    g.setColor(AbstractTool.color);

    g.drawLine(getPressX(), getPressY(), e.getX(), e.getY());

    setPressX(e.getX());

    setPressY(e.getY());

    getFrame().getDrawSpace().repaint();

    }

    }

    }

     

      c.画矩形

        public class RectTool extends AbstractTool {

    	private static Tool tool = null;
    
    	private RectTool(DrawFrame frame) {
    		super(frame);
    	}
    
    	public static Tool getInstance(DrawFrame frame) {
    		if (tool == null) {
    			tool = new RectTool(frame);
    		}
    		return tool;
    	}
    
    	/*
    	 * 画图形
    	 */
    	public void draw(Graphics g, int x1, int y1, int x2, int y2) {
    		// 计算起点
    		int x = x2 > x1 ? x1 : x2;
    		int y = y2 > y1 ? y1 : y2;
    		// 画矩形
    		g.drawRect(x, y, Math.abs(x1 - x2), Math.abs(y1 - y2));
    	}
    }
    

     

        d.画椭圆

        public class RoundTool extends AbstractTool {

    private static Tool tool = null;

     

    private RoundTool(DrawFrame frame) {

    super(frame);

    }

     

    public static Tool getInstance(DrawFrame frame) {

    if (tool == null) {

    tool = new RoundTool(frame);

    }

    return tool;

    }

     

    /*

    * 画图形 

    * g画布对象

    * x1起点x坐标

    * y1起点y坐标

    * x2终点x坐标

    * y2终点y坐标

    * void

    */

    public void draw(Graphics g, int x1, int y1, int x2, int y2) {

    // 计算起点

    int x = x2 > x1 ? x1 : x2;

    int y = y2 > y1 ? y1 : y2;

    // 画椭圆

    g.drawOval(x, y, Math.abs(x1 - x2), Math.abs(y1 - y2));

    }

    }


    5.设置颜色面板类

       

    public class ColorPanel extends JPanel {
    
    	/*
    	 * 构造函数初始化面板的功能
    	 */
    	public ColorPanel(JPanel currentColorPanel){
    		// 设置布局方式
    		this.setLayout(new FlowLayout(FlowLayout.LEFT));
    		// 新建一个JToolBar
    		JToolBar toolBar = new JToolBar("颜色");
    		// 设置为不可拖动
    		toolBar.setFloatable(false);
    		// 设置与边界的距离
    		toolBar.setMargin(new Insets(2, 2, 2, 2));
    		// 设置布局方式
    		toolBar.setLayout(new GridLayout(2, 6, 2, 2));
    		// Color类中的已有颜色
    		Color[] colorArr = { Color.BLACK, Color.BLUE, Color.CYAN, Color.GRAY, Color.GREEN, Color.LIGHT_GRAY,
    				Color.MAGENTA, Color.ORANGE, Color.PINK, Color.RED, Color.WHITE, Color.YELLOW };
    		JButton[] panelArr = new JButton[colorArr.length];
    		currentColorPanel.setBackground(Color.BLACK);
    		currentColorPanel.setPreferredSize(new Dimension(20, 20));
    		// 创建这些颜色的button
    		for (int i = 0; i < panelArr.length; i++) {
    			// 创建JButton
    			panelArr[i] = new JButton(new ImageAction(colorArr[i],
    					currentColorPanel));
    			// 设置button的颜色
    			panelArr[i].setBackground(colorArr[i]);
    			// 把button加到toolbar中
    			toolBar.add(panelArr[i]);
    		}
    		this.add(currentColorPanel);
    		this.add(toolBar);
    	}
    	
    }

     

        设置颜色面板时要注意,在左边设置一个前景色和一个背景色,然后使用网格布局显示各种颜色,颜色也可从RGB颜色       对照表获得。

     

        public class ColorPanel extends JPanel{

    	
    	   private JPanel panel=new JPanel();   
    	   private JPanel panel1=new JPanel();
    	
    	   public void show_colorPanel(){
                  panel.setLayout(new FlowLayout(FlowLayout.LEFT));
                  
                  panel.setPreferredSize(new Dimension(30,30));
                  panel.setLayout(null);
                  panel.setBackground(Color.DARK_GRAY);
                  
                  JButton button1=new JButton();
                  button1.setBounds(5, 5, 15, 15);
                  
                  JButton button2=new JButton();
                  button2.setBounds(5, 5, 15, 15);
                  
                  panel.add(button1);
                  panel.add(button2);
                  
                  
                  panel1.setPreferredSize(new Dimension(210,30));
                  panel1.setBackground(Color.LIGHT_GRAY);
                  panel1.setLayout(new GridLayout(2,14,2,2));
                  
                  for(int i=0;i<28;i++){
                	  JButton button3=new JButton();
                	  button3.setSize(new Dimension(15,15));
                	  panel1.add(button3);
                  }
                  
                  this.add(panel);
                  this.add(panel1);
    	   }
    }
    

     

    6.保存

       首先得到保存路径,

       然后截取路径,

       再用输入输出流,

       把其读入数组中,

       再将其写到指定的文件夹中,

       实现保存。

     

       使用java.io.DataOutputStream可直接输出字符型、整形、布尔型等,但之前要将基本流包装成特殊流。

     

       执行完毕时,要记得关闭流。

     

        public void saveFile(String path,ArrayList<Shape> shapes){

          try{

          //文件输出流

          FileOutputStream fos=new FileOutputStream(path);

          //将文件输出流包装成可写基本类型的流

          DataOutputStream dos=new DataOutputStream(fos);

          //先写入队列中图形个数

          dos.writeInt(shapes.size());

          //读取队列

          for(int i=0;i<shapes.size();i++){

          //取出一种形状

          Shape shape=shapes.get(i);

          byte type=shape.type;

          //写形状类型

          dos.writeByte(type);

          //根据type判断类型如果是直线

          if(type==0){

         //强制类型转换成直线类

         ImpLine line=(ImpLine) shape;

         //写直线形状的数据

         int x1=line.x1;

         int y1=line.y1;

         int x2=line.x2;

         int y2=line.y2;

         dos.writeInt(x1);

         dos.writeInt(y1);

         dos.writeInt(x2);

         dos.writeInt(y2);

          }

         

          }

          dos.flush();

          //关闭输出流

          fos.close();

          }catch(Exception ef){

             ef.printStackTrace();

          }

        }

     

        //读文件,将文件中的内容存入队列shapes,并返回

        public ArrayList<Shape> readFile(String path){

          //创建一个队列用来保存从文件中读取到的数据

          ArrayList<Shape> shapes=new ArrayList<Shape>();

          try{

          //创建文件对象的输入流

          FileInputStream fis=new FileInputStream(path);

          //将文件输入流包装成可读基本类型的流

          DataInputStream dis=new DataInputStream(fis);

          //先读取长度,即总共的形状个数

          int len=dis.readInt();

          //根据读取到的长度,得到循环次数

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

          //读图形类型

          byte type=dis.readByte();

          if(type==0){

         //如果type是0,表示接下来要读取的是直线的数据,创建直线对象

         LineShape line=new LineShape();

         //将读取的数据设置为直线的属性值

         line.type=type;

         line.x1=dis.readInt();

         line.y1=dis.readInt();

         line.x2=dis.readInt();

         line.y2=dis.readInt();

         //将直线存入队列

         shapes.add(line);

          }

          } 

         }catch(Exception e){

        e.printStackTrace();

          }

         return shapes;

          

        }

     

     

     

    7.BMP保存

       每种文件都是按照特定的格式进行存储的,与后缀名无关

       BMP文件以存储方式为24位真彩色为例

     

       结构:a.BMP文件头(14字节)  仿BMP文件头(两个int数据:width和height,占8字节)

                b.位图信息头(40字节)

                c.颜色表(由颜色索引数决定)

                d.位图数据(由图像尺寸决定)

                   仿BMP的位图数据(width*height个int值)

     

    展开全文
  • java画板代码:代码功能可以实现在一个画板中画一些比较简单的几何图形。
  • java画板 比较简单的画板 ,初学者可以借鉴下!java画板 比较简单的画板 ,初学者可以借鉴下!java画板 比较简单的画板 ,初学者可以借鉴下!
  • java画板大作业

    2012-12-30 21:46:02
    Java是学校布置的大作业,适合刚学java编程这的学习,对学习很有帮助。
  • java编写的网络画板应用,应用socket技术,可选择当客户端以及服务器端,局域网连接,可实时聊天,实时显示多方所画内容,可选线条粗细,颜色,实线虚线,以及图形样式,界面简洁,功能强大方便扩展,通过多线程可...
  • 调用java画板画验证码

    2019-01-04 14:57:12
    1,web.xml配置代码  &lt;servlet&gt;  &lt;servlet-name&gt;Code&lt;/servlet-name&gt;  &lt;servlet-class&gt;com.util.Code&lt;/servlet-class&... &

    1,web.xml配置代码

     <servlet>
         <servlet-name>Code</servlet-name>
         <servlet-class>com.util.Code</servlet-class>
      </servlet>
      <servlet-mapping>
          <servlet-name>Code</servlet-name>
          <url-pattern>/Code</url-pattern>
      </servlet-mapping>

    2,jsp前端代码

    3,后端代码

    4,效果图

    展开全文
  • java画板支持图元

    2012-04-24 15:24:18
    java实现的画板程序,支持直线,矩形,圆,椭圆等图元。另外,它还会把每步操作写进文件,进行回放。
  • java画板项目总结

    2016-07-08 12:28:00
    具体如下:   package Simple_Draw; public class Draw { public static void main(String[] args) { DrawPanel dp = new DrawPanel(); dp.initJFrame(); } ...import java.awt.Bord...
  • 可运行的java画板

    2012-03-22 13:11:20
    这是一个由java编写的类似于windows中绘图的小程序,运用textpad绝对可运行。其中创建一种新格式,内有说明
  • Java之通信画板

    2021-03-21 15:43:13
    本次我们主要实现了画板之间的通信,客户端画板可以转递一条直线给服务端画板,服务端画板也可以传递一条直线给客户端画板,两端直线显示在相同位置上,效果如下: 涉及到的知识点主要有以下两点: 1,Java Socket...
  • 要求实现一个java画板程序: 1) 可以新建、打开并保存至少一种标准格式(如jpg)图像文件 2) 能在图像上画直线段、圆(弧)、椭圆(弧)、矩形、并能设置线宽度、颜色、填充颜色等 3) 能够设置参数浮点数d>=0,颜色值c1和c2...
  • java画板程序

    2008-06-08 18:47:41
    java写的经典画板程序,内附代码,可供学习
  • JAVA实现小画板课程设计 学习了《Java面向对象编程》的课程,为了更进一步的提高我们对Java的深入学习,进行了课程设计,我所选择课程设计是利用Java的GUI实现画图应用程度。其目的是通过本课程设计使我们能够较全面...
  • java实现的画板小程序 实现了画直线,矩形,三角形以及拖动图形功能

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,435
精华内容 2,974
关键字:

java画板

java 订阅