Java 在绘制矩形和徒手绘制之间切换

我的Java绘图程序有一些问题

我有一个

JComboBox

，在那里我可以选择绘制矩形或徒手绘制。这些对象将添加到

阵列列表中。我希望能够在绘制矩形和徒手之间切换，然后返回到绘制矩形，然后徒手。。。等等

如果我按照代码现在的样子这样做，它首先绘制矩形，然后当我切换到徒手时，它绘制线条，但是当我切换回矩形时，它仍然绘制线条（或者有时线条与奇怪的矩形一起）。我越是切换，它就变得越奇怪

有人能看出代码有什么问题吗，因为我看不出来

public abstract class Draw  {
    public int startX, startY, endX, endY, width, height, w, h;
    public String color = "Black";


    public Draw(int startX, int startY, int width, int height) {
        this.startX = startX;
        this.startY = startY;
        this.width = width;
        this.height = height;
    }

    public abstract void draw(Graphics2D g);       

    public int getX() {
        return startX;
    }

    public void setX(int startX) {
        this.startX = startX;
    }

    public int getY() {
        return startY;
    }

    public void setY(int startY) {
        this.startY = startY;
    }

    public int getWidth() {
        return width;
    }

    public void setWidth(int width) {
        this.width = width;
    }

    public int getHeight() {
        return height;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    public void setColor(String color) {
        this.color = color;
    }
}



public class Rectangle extends Draw {

    public Rectangle(int x, int y, int width, int height) {
        super(x, y, width, height);
    }        

    @Override
    public void draw(Graphics2D g2) {
        g2.drawRect(getX(), getY(), getWidth(), getHeight());
    }  
}

public class FreeHand extends Draw {

     public FreeHand(int x, int y, int width, int height) {
        super(x, y, width, height);
    }

    @Override
    public void draw(Graphics2D g2) {            
        g2.drawLine(getX(), getY(), getWidth(), getHeight());
    }
}

public class PaintProgram extends JFrame implements ActionListener {

    public ArrayList<Draw> shapeList = new ArrayList<>();   
    int startX, startY, endX, endY, w, h;
    private JPanel topPanel;   
    private JPanel bottomPanel;
    private JPanel leftPanel;
    private JPanel rightPanel;
    private JComboBox comboBox;
    private final String[] boxOptions = new String[] {"Rectangle", "Freehand"};   
    Container cp = getContentPane();
    private int count = 0;


    public JavaApplication30(String title) {
        super(title);
        this.setLayout(new BorderLayout());
        this.setDefaultCloseOperation(DO_NOTHING_ON_CLOSE);
        this.setLocationRelativeTo(null);        
        this.setSize(840, 500);     
        this.initComponents();
        this.setVisible(true);            
    }


    private void initComponents() {

        cp.setBackground(Color.WHITE);

        comboBox = new JComboBox(boxOptions);
        topPanel = new JPanel();     
        bottomPanel = new JPanel(new GridLayout(1,2));  
        rightPanel = new JPanel(new FlowLayout(FlowLayout.RIGHT));
        leftPanel = new JPanel(new FlowLayout(FlowLayout.LEFT));

        comboBox.setSelectedIndex(0);          
        comboBox.addActionListener(this); 

        topPanel.setPreferredSize(new Dimension(0,40));        
        bottomPanel.setPreferredSize(new Dimension(0,30));                       
        bottomPanel.setBackground(Color.LIGHT_GRAY);        

        topPanel.add(comboBox);
        bottomPanel.add(leftPanel);        
        bottomPanel.add(rightPanel);

        this.add(topPanel, BorderLayout.PAGE_START);          
        this.add(bottomPanel, BorderLayout.PAGE_END);                  
    }


    @Override
    public void paint(Graphics g) {
        if(count == 0) {
            cp.repaint();
        }
        Graphics2D g2 = (Graphics2D) g;

        for (Draw d : shapeList) {
            d.draw(g2);
        }        

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

        g2.setStroke(new BasicStroke(1));

        if (startX != 0 && startY != 0 && endX != 0 && endY != 0) {

            int width = Math.abs(startX - endX);
            int height = Math.abs(startY - endY);

            int minX = Math.min(startX, endX);
            int minY = Math.min(startY, endY);               

            Rectangle r = new Rectangle(minX, minY, width, height);

            g2.setPaint(Color.WHITE);
            g2.fillRect(r.getX(), r.getY(), r.getWidth(), r.getHeight()); 
            r.setColor(pickedColor);

            r.draw(g2);
        }
    }


    @Override
    public void actionPerformed(ActionEvent e) {

        count++;

        if (e.getSource().equals(comboBox)) {    

            JComboBox cb = (JComboBox)e.getSource();

            if (cb.getSelectedItem().equals("Rectangle")) {

                this.addMouseListener(new MouseAdapter() {    

                    @Override
                    public void mousePressed(MouseEvent e) {                   
                        startX = e.getX();     
                        startY = e.getY(); 

                        endX = startX;  
                        endY = startY;  
                        repaint(); 
                    }

                    @Override
                    public void mouseReleased(MouseEvent e) {
                        endX = e.getX();
                        endY = e.getY();

                        int width = Math.abs(startX - endX);
                        int height = Math.abs(startY - endY);

                        int minX = Math.min(startX, endX);
                        int minY = Math.min(startY, endY);               

                        Rectangle r =  new Rectangle(minX, minY, width, height);
                        shapeList.add(r);
                        r.setColor(pickedColor);

                        startX = 0;
                        startY = 0;
                        endX = 0;
                        endY = 0;
                        repaint();
                    }
                });    

                this.addMouseMotionListener(new MouseMotionAdapter() {
                    @Override
                    public void mouseDragged(MouseEvent e) {
                        endX = e.getX();
                        endY = e.getY();
                        repaint();
                    }
                });
            }            


            else if (cb.getSelectedItem().equals("Freehand")) {

                this.addMouseListener(new MouseAdapter() {                   
                    @Override
                    public void mousePressed(MouseEvent e) {                   
                        startX = e.getX();
                        startY = e.getY();                       
                        addCoordinate(startX, startY);
                    }
                });

                this.addMouseMotionListener(new MouseMotionAdapter() {
                    @Override
                    public void mouseDragged(MouseEvent e) {                
                        Graphics g = getGraphics();    
                        Graphics2D g2 = (Graphics2D) g;         

                        FreeHand fh =  new FreeHand(startX, startY, e.getX(), e.getY());
                        shapeList.add(fh);
                        fh.setColor(pickedColor);
                        fh.draw(g2);                    
                        startX = e.getX();
                        startY = e.getY();                         
                    }
                });    
            }
        }
    }                 

    public static void main(String args[]) {
        new PaintProgram("Paint");
    }
}

公共抽象类绘制{
公共int startX、startY、endX、endY、宽度、高度、w、h；
公共字符串color=“黑色”；
公共绘图（整数起点、整数起点、整数宽度、整数高度）{
this.startX=startX；
this.startY=startY；
这个。宽度=宽度；
高度=高度；
}
公共摘要空白图（图形2 d g）；
公共int getX（）{
返回startX；
}
公共无效setX（int startX）{
this.startX=startX；
}
公共int getY（）{
返星；
}
公共空间setY（国际标准）{
this.startY=startY；
}
公共int getWidth（）{
返回宽度；
}
公共void setWidth（int-width）{
这个。宽度=宽度；
}
公共整数getHeight（）{
返回高度；
}
公共空间设置高度（内部高度）{
高度=高度；
}
公共void setColor（字符串颜色）{
这个颜色=颜色；
}
}
公共类矩形扩展绘制{
公共矩形（整数x，整数y，整数宽度，整数高度）{
超级（x、y、宽度、高度）；
}        
@凌驾
公共空白绘图（图形2D g2）{
g2.drawRect（getX（），getY（），getWidth（），getHeight（））；
}  
}
公共类徒手画{
公共写意（整数x，整数y，整数宽度，整数高度）{
超级（x、y、宽度、高度）；
}
@凌驾
公共空白绘图（图形2D g2）{
g2.绘图线（getX（），getY（），getWidth（），getHeight（））；
}
}
公共类PaintProgram扩展JFrame实现ActionListener{
public ArrayList shapeList=new ArrayList（）；
int startX、startY、endX、endY、w、h；
私人杰帕内尔·托帕内尔；
私人JPanel小组；
私人JPanel leftPanel；
私人JPanel rightPanel；
专用JComboBox组合框；
私有最终字符串[]boxOptions=新字符串[]{“矩形”、“手绘”}；
容器cp=getContentPane（）；
私有整数计数=0；
公共JavaApplication30（字符串标题）{
超级（标题）；
此.setLayout（新的BorderLayout（））；
此.setDefaultCloseOperation（在关闭时不执行任何操作）；
此.setLocationRelativeTo（空）；
这个.setSize（840500）；
这个.initComponents（）；
此.setVisible（true）；
}
私有组件（）{
cp.背景（颜色：白色）；
comboBox=新的JComboBox（boxOptions）；
topPanel=新的JPanel（）；
底部面板=新JPanel（新网格布局（1,2））；
rightPanel=newjpanel（newflowlayout（FlowLayout.RIGHT））；
leftPanel=newjpanel（newflowlayout（FlowLayout.LEFT））；
comboBox.setSelectedIndex（0）；
comboBox.addActionListener（这个）；
topPanel.setPreferredSize（新尺寸（0,40））；
底部面板。设置首选尺寸（新尺寸（0,30））；
底板.立根底板（颜色.浅灰色）；
topPanel.add（组合框）；
添加（左面板）；
添加（右面板）；
添加（topPanel，BorderLayout.PAGE_START）；
添加（底部面板，边框布局，第_页结束）；
}
@凌驾
公共空间涂料（图g）{
如果（计数=0）{
cp.repaint（）；
}
图形2d g2=（图形2d）g；
for（图d：形状列表）{
d、 绘制（g2）；
}        
g2.setRenderingHint（renderingHits.KEY\u ANTIALIASING，renderingHits.VALUE\u ANTIALIAS\u ON）；
g2.设定行程（新基本行程（1））；
如果（startX！=0&&startY！=0&&endX！=0&&endY！=0）{
int width=Math.abs（startX-endX）；
int height=Math.abs（startY-endY）；
int minX=Math.min（startX，endX）；
int minY=Math.min（开始，结束）；
矩形r=新矩形（最小值、最小值、宽度、高度）；
g2.setPaint（颜色为白色）；
g2.fillRect（r.getX（），r.getY（），r.getWidth（），r.getHeight（））；
r、 setColor（pickedColor）；
r、 绘制（g2）；
}
}
@凌驾
已执行的公共无效操作（操作事件e）{
计数++；
如果（e.getSource（）.equals（组合框））{
JComboBox cb=（JComboBox）e.getSource（）；
if（cb.getSelectedItem（）.equals（“矩形”））{
this.addMouseListener（新的MouseAdapter（）{
@凌驾
公共无效鼠标按下（MouseEvent e）{
startX=e.getX（）；
startY=e.getY（）；
endX=startX；
endY=星形；
重新油漆（）；
}
@凌驾
公共无效MouseEvent（MouseEvent e）{
endX=e.getX（）；
endY=e.getY（）；
int width=Math.abs（startX-endX）；
int height=Math.abs（startY-endY）；
int minX=Math.min（startX，endX）；
int minY=Math.min（开始，结束）；
雷克坦
    for (MouseListener listener : this.getMouseListeners()) {
        this.removeMouseListener(listener);
    }
    for (MouseMotionListener listener : this.getMouseMotionListeners()) {
        this.removeMouseMotionListener(listener);
    }

public interface DrawFactory {

    public Draw createDrawing(int x, int y, int width, int height, Color color);
    public void addPoint(Draw draw, int x, int y);

}

public class RectangleFactory implements DrawFactory {

    @Override
    public Draw createDrawing(int x, int y, int width, int height, Color color) {
        return new Rectangle(x, y, width, height);
    }

    @Override
    public void addPoint(Draw draw, int x, int y) {
        // Does nothing...
    }

    @Override
    public boolean isMutable() {
        return false;
    }

    @Override
    public String getName() {
        return "Rectangle";
    }

    @Override
    public String toString() {
        return getName();
    }

}

public class FreeHandFactory implements DrawFactory {

    @Override
    public Draw createDrawing(int x, int y, int width, int height, Color color) {
        return new FreeHand(x, y, width, height);
    }

    @Override
    public void addPoint(Draw draw, int x, int y) {
        if (draw instanceof FreeHand) {
            FreeHand fh = (FreeHand)draw;
            //fh.addPoint(x, y);
        }
    }

    @Override
    public boolean isMutable() {
        return true;
    }

    @Override
    public String getName() {
        return "Free Hand";
    }

    @Override
    public String toString() {
        return getName();
    }

}

public class DrawSurface extends JPanel {

    private DrawFactory factory;
    private Draw currentDraw;
    private List<Draw> shapeList = new ArrayList<>();
    private Color drawColor;

    public DrawSurface() {
        shapeList = new ArrayList<>(25);
        MouseAdapter ma = new MouseAdapter() {

            private Point pressPoint;

            @Override
            public void mousePressed(MouseEvent e) {
                pressPoint = e.getPoint();
            }

            @Override
            public void mouseReleased(MouseEvent e) {
                DrawFactory factory = getDrawFactory();
                if (factory != null) {
                    Point p = e.getPoint();
                    if (factory.isMutable() && currentDraw != null) {
                        factory.addPoint(currentDraw, p.x, p.y);
                    } else {
                        int x = Math.min(p.x, pressPoint.x);
                        int y = Math.min(p.y, pressPoint.y);

                        int width = Math.abs(p.x - pressPoint.x);
                        int height = Math.abs(p.y - pressPoint.y);

                        Draw draw = factory.createDrawing(x, y, width, height, getDrawColor());
                        shapeList.add(draw);
                        if (factory.isMutable()) {
                            currentDraw = draw;
                        }
                    }
                }
            }
        };
    }

    public DrawFactory getDrawFactory() {
        return factory;
    }

    public void setDrawFactory(DrawFactory factory) {
        this.factory = factory;
        currentDraw = null;
    }

    public Color getDrawColor() {
        return drawColor;
    }

    public void setDrawColor(Color drawColor) {
        this.drawColor = drawColor;
    }

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        Graphics2D g2d = (Graphics2D) g.create();
        for (Draw draw : shapeList) {
            draw.draw(g2d);
        }
        g2d.dispose();
    }

    public Dimension getPreferredSize() {
        return new Dimension(200, 200);
    }

}

private final DrawFactory[] boxOptions = new DrawFactory[]{new RectangleFactory(), new FreeHandFactory()};
private DrawSurface drawSurface;

private void initComponents() {
    //...    
    drawSurface = new DrawSurface();
    this.add(drawSurface);
}

@Override
public void actionPerformed(ActionEvent e) {
    count++;
    drawSurface.setDrawFactory((DrawFactory)comboBox.getSelectedItem());
}