创建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"或者将数组等一些变量设置成功能面板的属性
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));
}
}
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值)
628
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
