向java绘图程序添加clear和undo Jbutton

我的项目遇到了障碍。 使用我从上一个问题中收到的代码，我复制了我的问题。 我需要添加一个clear and undo按钮。如您所见，我添加了按钮hpwever，但无法执行所需的操作。 我曾尝试将ActionListeners添加到创建按钮的类中，然后尝试这样做 itemsDrawn=新阵列列表；（用于清除） itemsDrawn.remove（itemsDrawn.size（）-1）（用于撤消） 作为结果操作，但程序锁定

基本上我做得对吗/我应该把ActionListeners放在哪里

任何帮助都将不胜感激

import java.awt.BasicStroke;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.LinearGradientPaint;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Shape;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Point2D;
import java.awt.geom.Line2D;
import java.util.ArrayList;
import java.util.List;
import javax.swing.JCheckBox;
import javax.swing.JColorChooser;
import javax.swing.JComboBox;
import javax.swing.JComponent;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JButton;
import javax.swing.JTextField;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;
import javax.swing.border.CompoundBorder;
import javax.swing.border.EmptyBorder;
import javax.swing.border.LineBorder;

public class MyPaint {

    static ArrayList<Drawable> itemsDrawn;
    static JButton Clear,Undo;

    public static void main(String[] args) {
        new MyPaint();
    }

    public MyPaint() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                try {
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) {
                }

                JFrame frame = new JFrame("Java 2D Drawing");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setLayout(new BorderLayout());

                DrawablePane dp = new DrawablePane();
                ControlPane cp = new ControlPane(dp);

                frame.add(dp);
                frame.add(cp, BorderLayout.NORTH);

                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public class State {

        private final Color foreground;
        private final Color background;
        private final boolean gradient;
        private final boolean filled;
        private final boolean dashed;
        private int LineWidth, DashLength;

        public State(Color foreground, Color background, boolean gradient, boolean filled, boolean dashed,int LineWidth, int DashLength) {
            this.foreground = foreground;
            this.background = background;
            this.gradient = gradient;
            this.filled = filled;
            this.dashed = dashed;
            this.LineWidth = LineWidth;
            this.DashLength = DashLength;

        }

        public Color getBackground() {
            return background;
        }

        public Color getForeground() {
            return foreground;
        }

        public boolean isGradient() {
            return gradient;
        }
        public boolean isFilled() {
            return filled;
        }
        public boolean isDashed(){
            return dashed;
        }
        public int getLineWidth(){
                return LineWidth;
        }
        public int getDashLength(){
            return DashLength;
        }

    }

    public class ControlPane extends JPanel {

        private JComboBox shapes;
        private JLabel foreground;
        private JLabel background;
        private JCheckBox gradient,Filled,dashed;
        private JTextField Dashlength,Linewidth;
        private JLabel Len,Wid;


        private DrawablePane drawablePane;

        public ControlPane(DrawablePane pane) {

            shapes = new JComboBox<>(new String[]{"Rectangle", "Oval","Line"});
            foreground = createColorLable(Color.BLACK);
            foreground.setToolTipText("Foreground");
            background = createColorLable(Color.WHITE);
            background.setToolTipText("Background");
            gradient = new JCheckBox("Gradient");
            Filled = new JCheckBox("Filled");
            dashed = new JCheckBox("Dashed");
            Dashlength = new JTextField("1");
            Linewidth = new JTextField("1");
            Len = new JLabel("Dash Length:");
            Wid = new JLabel("Line Width:");
            Clear = new JButton("Clear");
            Undo = new JButton("Undo");






            JPanel panel = new JPanel();
            panel.add(Clear);
            panel.add(Undo);
            panel.add(foreground);
            panel.add(background);
            panel.add(Filled);

            setLayout(new GridBagLayout());
            GridBagConstraints gbc = new GridBagConstraints();
            gbc.gridwidth = GridBagConstraints.REMAINDER;
            gbc.fill = GridBagConstraints.HORIZONTAL;
            gbc.weightx = 1;

            add(shapes, gbc);
            add(panel, gbc);
            gbc.weighty = 1;
            gbc.anchor = GridBagConstraints.NORTH;
            add(gradient, gbc);
            add(dashed, gbc);
            add(Len);
            add(Linewidth);
            add(Wid);
            add(Dashlength);



            setBorder(new CompoundBorder(new LineBorder(Color.BLACK), new EmptyBorder(12, 12, 12, 12)));

            this.drawablePane = pane;
            MouseHandler mouseHandler = new MouseHandler();
            drawablePane.addMouseListener(mouseHandler);
            drawablePane.addMouseMotionListener(mouseHandler);


        }



                public int getDash(){
                String Length = Dashlength.getText();
                int Dash = Integer.parseInt(Length);
                return Dash;
            }
                public int getLine(){
                String LWidth = Linewidth.getText();
                int Line = Integer.parseInt(LWidth);
                return Line;
                }

        protected Drawable createDrawable() {

            Drawable drawable = null;
            State state = new State(foreground.getBackground(), background.getBackground(), gradient.isSelected(), Filled.isSelected(), dashed.isSelected(),getLine(), getDash());
            String selected = (String) shapes.getSelectedItem();
            if ("rectangle".equalsIgnoreCase(selected)) {
                drawable = new Square(state);
            } else if ("oval".equalsIgnoreCase(selected)) {
                drawable = new Circle(state);
            }
            else if ("Line".equalsIgnoreCase(selected)){
                drawable = new Line(state);
            }

            return drawable;

        }

        protected JLabel createColorLable(Color base) {
            final JLabel label = new JLabel();
            label.setBackground(base);
            label.setBorder(new LineBorder(Color.BLACK));
            label.setPreferredSize(new Dimension(25, 25));
            label.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
            label.setOpaque(true);
            label.addMouseListener(new MouseAdapter() {
                @Override
                public void mousePressed(MouseEvent e) {
                    Color color = JColorChooser.showDialog(label, "Color", label.getBackground());
                    if (color != null) {
                        label.setBackground(color);
                    }
                }
            });
            return label;
        }

        public class MouseHandler extends MouseAdapter {

            private Drawable drawable;
            private Point clickPoint;

            @Override
            public void mousePressed(MouseEvent e) {
                drawable = createDrawable();
                drawable.setLocation(e.getPoint());
                drawablePane.addDrawable(drawable);
                clickPoint = e.getPoint();
            }

            @Override
            public void mouseDragged(MouseEvent e) {
                Point drag = e.getPoint();
                Point start = clickPoint;

                int maxX = Math.max(drag.x, start.x);
                int maxY = Math.max(drag.y, start.y);
                int minX = Math.min(drag.x, start.x);
                int minY = Math.min(drag.y, start.y);

                int width = maxX - minX;
                int height = maxY - minY;

                drawable.setLocation(new Point(minX, minY));
                drawable.setSize(new Dimension(width, height));

                drawablePane.repaint();
            }

        }

    }

    public interface Drawable {

        public void paint(JComponent parent, Graphics2D g2d);

        public void setLocation(Point location);

        public void setSize(Dimension size);

        public State getState();

        public Rectangle getBounds();

    }

    public abstract class AbstractDrawable implements Drawable {

        private Rectangle bounds;
        private State state;

        public AbstractDrawable(State state) {
            bounds = new Rectangle();
            this.state = state;
        }

        @Override
        public State getState() {
            return state;
        }

        public abstract Shape getShape();

        @Override
        public void setLocation(Point location) {
            bounds.setLocation(location);
        }

        @Override
        public void setSize(Dimension size) {
            bounds.setSize(size);
        }

        @Override
        public Rectangle getBounds() {
            return bounds;
        }

        @Override
        public void paint(JComponent parent, Graphics2D g2d) {

            Shape shape = getShape();
            State state = getState();
            Rectangle bounds = getBounds();
            final float dash1[] = {state.LineWidth};
            final BasicStroke dashed =
            new BasicStroke(state.DashLength,
                        BasicStroke.CAP_BUTT,
                        BasicStroke.JOIN_MITER,
                        10.0f, dash1, 0.0f);

            if (bounds.width > 0 && bounds.height > 0) {
                 if (state.isGradient()){
                     if (state.isDashed()){
                     Point2D startPoint = new Point2D.Double(bounds.x, bounds.y);
            Point2D endPoint = new Point2D.Double(bounds.x + bounds.width, bounds.y + bounds.height);
            LinearGradientPaint gp = new LinearGradientPaint(
                            startPoint,
                            endPoint,
                            new float[]{0f, 1f},
                            new Color[]{state.getForeground(), state.getBackground()});    
                    g2d.setPaint(gp);
                    g2d.setStroke(dashed);
                    g2d.draw(shape);
                }
                     else{
            Point2D startPoint = new Point2D.Double(bounds.x, bounds.y);
            Point2D endPoint = new Point2D.Double(bounds.x + bounds.width, bounds.y + bounds.height);
            LinearGradientPaint gp = new LinearGradientPaint(
                            startPoint,
                            endPoint,
                            new float[]{0f, 1f},
                            new Color[]{state.getForeground(), state.getBackground()});
                     g2d.setPaint(gp);
                     g2d.fill(shape);
                     }
                 }

            else if (state.isFilled()){
                if (bounds.width > 0 && bounds.height > 0) {

                g2d.setPaint(state.getForeground());
                g2d.fill(shape);


                }
                }
            else if(state.isDashed()){
                g2d.setStroke(dashed);
                g2d.setPaint(state.getForeground());
                g2d.draw(shape);

            } 
            else{
                 BasicStroke stroke = new BasicStroke();
                 g2d.setStroke(stroke);
                g2d.setPaint(state.getForeground());
                g2d.draw(shape);
            }
        }
        }
        }


    public class Square extends AbstractDrawable {

        public Square(State state) {
            super(state);
        }

        @Override
        public Shape getShape() {
            return getBounds();
        }

    }

    public class Circle extends AbstractDrawable {

        public Circle(State state) {
            super(state);
        }

        @Override
        public Shape getShape() {
            Rectangle bounds = getBounds();
            return new Ellipse2D.Float(bounds.x, bounds.y, bounds.width, bounds.height);
        }

    }

    public class Line extends AbstractDrawable {

        public Line(State state){
            super(state);
        }
        @Override
        public Shape getShape() {
           Rectangle bounds = getBounds();
           return new Line2D.Float(bounds.x, bounds.y,bounds.width, bounds.height);

        }
    }

    public class DrawablePane extends JPanel {

        List<Drawable> itemsDrawn;

        public DrawablePane() {
            itemsDrawn =  new ArrayList<>();
        }

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

        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            Graphics2D g2d = (Graphics2D) g.create();
            for (Drawable d : itemsDrawn) {
                d.paint(this, g2d);
            }
            g2d.dispose();
        }

        public void addDrawable(Drawable drawable) {

            itemsDrawn.add(drawable);
            repaint();

        }



               }
           }

import java.awt.BasicStroke；
导入java.awt.BorderLayout；
导入java.awt.Color；
导入java.awt.Cursor；
导入java.awt.Dimension；
导入java.awt.EventQueue；
导入java.awt.Graphics；
导入java.awt.Graphics2D；
导入java.awt.GridBagConstraints；
导入java.awt.GridBagLayout；
导入java.awt.LinearGradientPaint；
导入java.awt.Point；
导入java.awt.Rectangle；
导入java.awt.Shape；
导入java.awt.event.ActionEvent；
导入java.awt.event.ActionListener；
导入java.awt.event.MouseAdapter；
导入java.awt.event.MouseEvent；
导入java.awt.geom.Ellipse2D；
导入java.awt.geom.Point2D；
导入java.awt.geom.Line2D；
导入java.util.ArrayList；
导入java.util.List；
导入javax.swing.JCheckBox；
导入javax.swing.JColorChooser；
导入javax.swing.JComboBox；
导入javax.swing.JComponent；
导入javax.swing.JFileChooser；
导入javax.swing.JFrame；
导入javax.swing.JLabel；
导入javax.swing.JPanel；
导入javax.swing.JButton；
导入javax.swing.JTextField；
导入javax.swing.UIManager；
导入javax.swing.UnsupportedLookAndFeelException；
导入javax.swing.border.CompoundBorder；
导入javax.swing.border.EmptyBorder；
导入javax.swing.border.LineBorder；
公共级MyPaint{
静态arraylistitemsdrawn；
静态按钮清除，撤消；
公共静态void main（字符串[]args）{
新MyPaint（）；
}
公共油漆（）{
invokeLater（新的Runnable（）{
@凌驾
公开募捐{
试一试{
UIManager.setLookAndFeel（UIManager.getSystemLookAndFeelClassName（））；
}catch（ClassNotFoundException |实例化Exception | IllegalacessException |不支持ookandfeelException ex）{
}
JFrame=新的JFrame（“Java 2D图纸”）；
frame.setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
frame.setLayout（新的BorderLayout（））；
DrawablePane dp=新的DrawablePane（）；
ControlPane cp=新的ControlPane（dp）；
帧。添加（dp）；
框架。添加（cp，边界布局。北）；
frame.pack（）；
frame.setLocationRelativeTo（空）；
frame.setVisible（true）；
}
});
}
公共阶级国家{
私有最终颜色前景；
私人最终颜色背景；
私有最终布尔梯度；
私有最终布尔填充；
私有最终布尔虚线；
专用int线宽，DashLength；
公共状态（彩色前景、彩色背景、布尔渐变、布尔填充、布尔虚线、int线宽、int虚线长度）{
this.foreground=前景；
this.background=背景；
这个梯度=梯度；
这个.填充的=填充的；
这个。虚线=虚线；
this.LineWidth=线宽；
this.DashLength=DashLength；
}
公共颜色getBackground（）{
返回背景；
}
公共颜色getForeground（）{
返回前景；
}
公共布尔梯度（）{
回归梯度；
}
公共布尔值已填充（）{
填写报税表；
}
公共布尔值isDashed（）{
返回虚线；
}
public int getLineWidth（）{
返回线宽；
}
public int getDashLength（）{
返回长度；
}
}
公共类控制面板扩展了JPanel{
私有JComboBox形状；
私有JLabel前景；
私人背景；
专用JCheckBox渐变，填充，虚线；
专用JTextField Dashlength、Linewidth；
私家侦探杰拉贝尔·莱恩，Wid；
私人可提取窗格玻璃可提取窗格玻璃；
公共控制窗格（可绘制窗格）{
shapes=newjcombobox（新字符串[]{“矩形”、“椭圆形”、“直线”}）；
前景=createColorLable（Color.BLACK）；
前台。setToolTipText（“前台”）；
背景=createColorLable（Color.WHITE）；
background.setToolTiptText（“背景”）；
梯度=新的JCheckBox（“梯度”）；
填充=新的JCheckBox（“填充”）；
虚线=新的JCheckBox（“虚线”）；
Dashlength=新的JTextField（“1”）；
线宽=新的JTextField（“1”）；
Len=新的JLabel（“破折号长度：”）；
Wid=新的JLabel（“线宽：”）；
清除=新的按钮（“清除”）；
撤销=新的JButton（“撤销”）；
JPanel面板=新的JPanel（）；
面板。添加（清除）；
面板。添加（撤消）；
面板。添加（前景）；
面板。添加（背景）；
面板。添加（填写）；
setLayout（新的GridBagLayout（））；
GridBagConstraints gbc=新的GridBagConstraints（）；
gbc.gridwidth=GridBagConstraints.rements；
gbc.fill=GridBagConstraints.HORIZONTAL；
gbc.weightx=1；
添加（形状、gbc）；
添加（面板，gbc）；
gbc.weighty=1；
gbc.anchor=gridbag.NORTH；
添加（梯度，gbc）；
添加（虚线，gbc）；
添加（Len）；
添加（线宽）；
添加（Wid）；
添加（短划线长度）；
public ControlPane(DrawablePane pane) {

            shapes = new JComboBox<>(new String[]{"Rectangle", "Oval","Line"});
            foreground = createColorLable(Color.BLACK);
            foreground.setToolTipText("Foreground");
            background = createColorLable(Color.WHITE);
            background.setToolTipText("Background");
            gradient = new JCheckBox("Gradient");
            Filled = new JCheckBox("Filled");
            dashed = new JCheckBox("Dashed");
            Dashlength = new JTextField("1");
            Linewidth = new JTextField("1");
            Len = new JLabel("Dash Length:");
            Wid = new JLabel("Line Width:");
            Clear = new JButton("Clear");
            Undo = new JButton("Undo");






            JPanel panel = new JPanel();
            panel.add(Clear);
            panel.add(Undo);
            panel.add(foreground);
            panel.add(background);
            panel.add(Filled);

            setLayout(new GridBagLayout());
            GridBagConstraints gbc = new GridBagConstraints();
            gbc.gridwidth = GridBagConstraints.REMAINDER;
            gbc.fill = GridBagConstraints.HORIZONTAL;
            gbc.weightx = 1;

            add(shapes, gbc);
            add(panel, gbc);
            gbc.weighty = 1;
            gbc.anchor = GridBagConstraints.NORTH;
            add(gradient, gbc);
            add(dashed, gbc);
            add(Len);
            add(Linewidth);
            add(Wid);
            add(Dashlength);



            setBorder(new CompoundBorder(new LineBorder(Color.BLACK), new EmptyBorder(12, 12, 12, 12)));

            this.drawablePane = pane;
            MouseHandler mouseHandler = new MouseHandler();
            drawablePane.addMouseListener(mouseHandler);
            drawablePane.addMouseMotionListener(mouseHandler);

            Clear.addActionListener(new ActionListener() {

           @Override
           public void actionPerformed(ActionEvent arg0) {
               // TODO Auto-generated method stub
               itemsDrawn = new ArrayList<>();
               (Not sure what to use here).repaint();
           }
       });
            undo.addActionListener(new ActionListener() {

           @Override
           public void actionPerformed(ActionEvent arg0) {
               // TODO Auto-generated method stub
               if (itemsDrawn.size() != 0) {
                   itemsDrawn.remove(itemsDrawn.size() - 1);
                   (Not sure what to put here).repaint();
               }
           }
       });

        }

Clear.addActionListner(new ActionListener() {
                @Override
                public void actionPreformed(ActionEvent arg0){
                    Clear();
                }
            });

          Undo.addActionListener(new ActionListener() {

           @Override
           public void actionPerformed(ActionEvent arg0) {
               // TODO Auto-generated method stub
               Undo();
           }
       });
public class DrawablePane extends JPanel {

        List<Drawable> itemsDrawn;

        public DrawablePane() {
            itemsDrawn =  new ArrayList<>();

        }
        public void undo(){
            if (itemsDrawn.size() != 0) {
                   itemsDrawn.remove(itemsDrawn.size() - 1);
                   repaint();
        }
        }
        public void Clear(){
             itemsDrawn = new ArrayList<>();
               repaint();

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

        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            Graphics2D g2d = (Graphics2D) g.create();
            for (Drawable d : itemsDrawn) {
                d.paint(this, g2d);
            }
            g2d.dispose();
        }

        public void addDrawable(Drawable drawable) {

            itemsDrawn.add(drawable);
            repaint();

        }



               }
           }

public class DrawablePane extends JPanel {
    private BufferedImage img = new BufferedImage(IMG_WIDTH, IMG_HEIGHT, BufferedImage.TYPE_INT_ARGB);

    List<Drawable> itemsDrawn;

    public DrawablePane() {
        itemsDrawn =  new ArrayList<>();
    }

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

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        if (img != null) {
           g.drawImage(img, 0, 0, this);
        }
     }

     public void addDrawable(Drawable drawable) {
        itemsDrawn.add(drawable);
        repaint();
     }

     public void clear() {
       img = new BufferedImage(IMG_WIDTH, IMG_HEIGHT, BufferedImage.TYPE_INT_ARGB);
       repaint();
     }

}

public class DrawablePane extends JPanel {

    List<Drawable> itemsDrawn;

    public DrawablePane() {
        itemsDrawn = new ArrayList<>();
    }

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

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        Graphics2D g2d = (Graphics2D) g.create();
        for (Drawable d : itemsDrawn) {
            d.paint(this, g2d);
        }
        g2d.dispose();
    }

    public void addDrawable(Drawable drawable) {

        itemsDrawn.add(drawable);
        repaint();

    }

    public void undo() {

        if (!itemsDrawn.isEmpty()) {

            int size = itemsDrawn.size() - 1;
            itemsDrawn.remove(size);
            repaint();

        }

    }

    public void clear() {

        itemsDrawn.clear();
        repaint();

    }

}

clear.addActionListner(new ActionListener() {
    @Override
    public void actionPreformed(ActionEvent arg0) {
        drawablePane.clear();
    }
});

undo.addActionListener(new ActionListener() {

    @Override
    public void actionPerformed(ActionEvent arg0) {
        drawablePane.undo();
    }
});