画笔工具

功能

首先我们确定我们的画笔中需要的功能：画线条、画等腰三角形、画矩形、画椭圆、颜色的选择已经更改、线条的加粗和变细、撤销、清除和保存。然后我们建立一个继承了JFrame类的子类PaintBrushFrame：

public class PaintBrushFrame extends JFrame {

    public PaintBrushFrame() {
        this.setTitle("我的绘图工具");
        this.setSize(800, 600);
        this.setResizable(false);
        this.setLocationRelativeTo(null);
        this.setDefaultCloseOperation(EXIT_ON_CLOSE);
  }
public static void main(String[] args) {
        new PaintBrushFrame().setVisible(true);
    }
}

先创建出一个固定大小居中不可变的窗口，然后我们将要实现的功能按钮分为两类：1.图形类 2.应用类。
建立图形抽象类：

public abstract class Shape {

    protected int startX;
    protected int startY;
    protected int endX;
    protected int endY;
    protected Color color;
    protected int lineWidth;
    
    /**
     * 画图
     * @param g 画笔
     */
    public void draw(Graphics g){
        g.setColor(color);
        ((Graphics2D) g).setStroke(new BasicStroke(lineWidth));;
    }
    
    
    /**
     * 修改初始横坐标
     * @param startX 初始横坐标
     */
    public void setStartX(int startX) {
        this.startX = startX;
    }
    /**
     * 修改初始纵坐标
     * @param startY 初始纵坐标
     */
    public void setStartY(int startY) {
        this.startY = startY;
    }
    /**
     * 修改终点横坐标
     * @param endX 终点横坐标
     */
    public void setEndX(int endX) {
        this.endX = endX;
    }
    /**
     * 修改终点纵坐标
     * @param endY 终点纵坐标
     */
    public void setEndY(int endY) {
        this.endY = endY;
    }
    /**
     * 修改颜色
     * @param color 颜色
     */
    public void setColor(Color color) {
        this.color = color;
    }
    /**
     * 修改粗细
     * @param lineWidth 粗细
     */
    public void setLineWidth(int lineWidth) {
        this.lineWidth = lineWidth;
    }
    

}

建立图形抽象类的子类线条类：

public class Line extends Shape {

    @Override
    public void draw(Graphics g) {
        super.draw(g);
        g.drawLine(startX, startY, endX, endY);
    }
}

建立图形抽象类的子类椭圆类

public class Oval extends Shape {

    @Override
    public void draw(Graphics g) {
        super.draw(g);
        int x = startX<endX?startX:endX;
        int y = startY<endY?startY:endY;
        int width = Math.abs(startX-endX);
        int height = Math.abs(startY-endY);
        g.drawOval(x, y, width, height);
    }   
}

建立图形抽象类的子类矩形类

public class Rectangle extends Shape {

    @Override
    public void draw(Graphics g) {
        super.draw(g);
        int x = startX<endX?startX:endX;
        int y = startY<endY?startY:endY;
        int width = Math.abs(startX-endX);
        int height = Math.abs(startY-endY);
        g.drawRect(x, y, width, height);
        
        
    }
}

建立图形抽象类的子类等腰三角形类

public class Triangle extends Shape{

    @Override
    public void draw(Graphics g) {
        super.draw(g);
        int x1 = startX>endX?startX:endX;
        int y1 = startY>endY?startY:endY;
        int width =Math.abs(startX-endX);
        int x2 = x1 - width;
        int y2 = y1;
        int x3 = (startX<endX?startX:endX)+width/2;
        int y3 = startY <endY?startY:endY;
        g.drawPolygon(new int[] {x1, x2,x3},new int[] {y1,y2,y3},3);//画三角形
//      g.drawLine(x1, y1, x2, y2);
//      g.drawLine(x3, y3, x2, y2);
//      g.drawLine(x1, y1, x3, y3);

        
    }

}

这个时候我们如果要创建图形类的对象需要分别对这四种不同的图形操作，这时我们可以再创建一个图形的工厂类ShapeFactory，运用多态的实现方法创建一个ShapeFactory的对象然后再对应实现：

public class ShapeFactory {
//静态的东西属于一个类，不属于这个类的任何一个对象
    /**
     * 创建图形的工厂方法
     * @param shapeType 类型
     * @return 图形对象或null
     */
    public static Shape createShape(String shapeType){
        Shape currentShape = null;
        switch (shapeType) {
            case "矩形" :
                currentShape = new Rectangle();
                break;
            case "椭圆" :
                currentShape = new Oval();
                break;
            case "三角形":
                currentShape = new Triangle();
                break;
            case  "线条" :
                currentShape = new Line();
                break;
        }
        return currentShape;
    }
    
}

最后通过按钮操作，鼠标点击和松开事件的监听，计时器和画笔完成：

@SuppressWarnings("serial")
public class PaintBrushFrame extends JFrame {

    private BufferedImage image = new BufferedImage(800, 600, 1);
    private List<Shape> shapesArray = new ArrayList<>();
    private String currentType = "线条";
    private Color defeultColor = Color.BLACK;
    private int defeultLineWidth = 1;

    public PaintBrushFrame() {
        this.setTitle("我的绘图工具");
        this.setSize(800, 600);
        this.setResizable(false);
        this.setLocationRelativeTo(null);
        this.setDefaultCloseOperation(EXIT_ON_CLOSE);

        JPanel buttonPanel = new JPanel();
        this.add(buttonPanel, BorderLayout.SOUTH);
        String[] buttonNames = {"线条", "矩形", "椭圆", "等腰三角形"};
        for (String name : buttonNames) {
            JButton button = new JButton(name);
            button.addActionListener(evt -> {
                currentType = evt.getActionCommand();
            });
            buttonPanel.add(button);
        }

        String[] buttonNames2 = {"选择颜色", "-", "+", "撤销", "清空", "保存"};
        for (String name : buttonNames2) {
            JButton button = new JButton(name);
            button.addActionListener(evt -> {
                String command = evt.getActionCommand();
                if (command.equals("选择颜色")) {
                    Color currentColor = JColorChooser.showDialog(
                            PaintBrushFrame.this, "请选择颜色", defeultColor);
                    defeultColor = currentColor != null
                            ? currentColor
                            : defeultColor;
                } else if (command.equals("-")) {
                    if (defeultLineWidth > 0) {
                        defeultLineWidth--;
                    }

                } else if (command.equals("+")) {
                    defeultLineWidth++;
                }

                else if (command.equals("撤销")) {
                    if (!shapesArray.isEmpty()) {
                        // Java虽然拥有垃圾回收（Garbage Collection）机制
                        // 但如果程序编写不当仍然有可能造成内存泄漏
                        // 垃圾回收是针对内存堆空间的无用对象清理工作
                        shapesArray.remove(shapesArray.size() - 1);// 防止内存泄漏，为了让垃圾回收器可以回收
                        repaint();
                    }

                } else if (command.equals("清空")) {
                    if (!shapesArray.isEmpty()) {
                        shapesArray.clear();
                    }
                    repaint();
                } else if (command.equals("保存")) {
                    JFileChooser chooser = new JFileChooser();
                    int choice = chooser.showSaveDialog(PaintBrushFrame.this);
                    if (choice == JFileChooser.APPROVE_OPTION) {
                        BufferedImage newImage = new BufferedImage(800, 600, 1);
                        Graphics graphics = newImage.getGraphics();
                        graphics.setColor(Color.WHITE);
                        graphics.fillRect(0, 0, 800, 600);
                        for (Shape shape : shapesArray) {
                            shape.draw(graphics);;
                        }
                        // for (int i = 0; i < totalShapes; i++) {
                        // shapesArray[i].draw(graphics);// 使用多态实现画图功能
                        // }
                        try {
                            ImageIO.write(image, "PNG",
                                    chooser.getSelectedFile());
                        } catch (IOException e1) {
                            e1.printStackTrace();
                        }
                    }

                }

            });
            buttonPanel.add(button);
        }

        /*
         * 缺省适配模式 给窗口或者窗口上的控件注册事件监听器有三种做法： 1.创建匿名内部类的对象（就地实例化）
         * 2.创建一个内部类对象充当监听器（因为有名字随时都可以创建对象） 3.让窗口实现接口用窗口对象充当监听器 从Java
         * 8开始，对于单方法接口（函数式接口）可以使用Lambda表达式 使用Lambda表达式其实就是写一个匿名方法来编写事件回调代码
         */
        MouseAdapter adapter = new MouseAdapter() {

            @Override
            public void mousePressed(MouseEvent e) {
                int x = e.getX();
                int y = e.getY();
                // 用工厂创建对象（根具体的图形类型实现解耦和）
                // // 画线 Shape currentShape = new Line();//画线
                // // Shape currentShape = new Rectangle();//画矩形
                // // Shape currentShape = new Oval();//画圆
                // Shape currentShape = null;
                // switch (currentType) {
                // case "矩形" :
                // currentShape = new Rectangle();
                // break;
                // case "椭圆" :
                // currentShape = new Oval();
                // break;
                // case "三角形" :
                // currentShape = new Triangle();
                // break;
                //
                // default :
                // currentShape = new Line();
                // break;
                // }
                Shape currentShape = ShapeFactory.createShape(currentType);

                currentShape.setColor(defeultColor);
                currentShape.setLineWidth(defeultLineWidth);
                currentShape.setStartX(x);
                currentShape.setStartY(y);
                currentShape.setEndX(x);
                currentShape.setEndY(y);
                shapesArray.add(currentShape);
            }

            @Override
            public void mouseDragged(MouseEvent e) {
                Shape currentShape = shapesArray.get(shapesArray.size() - 1);
                int x = e.getX();
                int y = e.getY();
                currentShape.setEndX(x);
                currentShape.setEndY(y);
                repaint();
            }
        };
        this.addMouseListener(adapter);
        this.addMouseMotionListener(adapter);

        // currentShape.setStartX(50);
        // currentShape.setStartY(80);
        // currentShape.setEndX(500);
        // currentShape.setEndY(380);

    }

    // 该方法为回调方法
    @Override
    public void paint(Graphics g) {
        Graphics otherGraphics = image.getGraphics();
        super.paint(otherGraphics);
        for (Shape shape : shapesArray) {
            shape.draw(otherGraphics);
        }
        g.drawImage(image, 0, 0, null);

    }

    public static void main(String[] args) {
        new PaintBrushFrame().setVisible(true);
    }
}