Java 拖动两个图像，并将它们放置在同一JFrame中的两个不同JButton中

我有一个代码，其中我必须从桌面拖动两个图像，然后用两个可拖动的按钮将其放到一个框架上。框架上的按钮已经制作好了。但在拖动图像时，只能将其拖动到一个按钮。图像不会被拖到另一个。我制作了一个

DragListener

类，其中以拖动方法为主，而主类

draginInitiallistener

在其中我传递了类

DragButton

的对象，以便创建两个可拖动的按钮。我尝试了我能想到的一切，制作了两个

DragListener

类，以不同的方式传递方法，但图像只能在一个按钮中拖动。我希望两个按钮都能保存图像。请帮帮我。以下是我迄今为止编写的代码：

//这是主课

public class DragInitialListener  extends javax.swing.JFrame {

private volatile int draggedAtX, draggedAtY;

public DragInitialListener() {

initComponents();
Droptargets();
Droptarget();
}

public void Droptarget()
{

DragListener d;
DragButton db = new DragButton();
db.setSize(170,140);
d= new DragListener(db);

DropTarget drop = new DropTarget(this,d);


this.getContentPane().add(db);
}

 public void Droptargets()
{

   DragListener dd;
    DragButton db1 = new DragButton();
   db1.setSize(170,140);


    dd= new DragListener(db1);

    DropTarget drop1 = new DropTarget(this,dd);



    this.getContentPane().add(db1);



   }

// <editor-fold defaultstate="collapsed" desc="Generated Code">                          
private void initComponents() {

    setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

    javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
    getContentPane().setLayout(layout);
    layout.setHorizontalGroup(
        layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
        .addGap(0, 400, Short.MAX_VALUE)
    );
    layout.setVerticalGroup(
        layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
        .addGap(0, 300, Short.MAX_VALUE)
    );

    pack();
}// </editor-fold>                        


 public static void main(String args[]) {


    /* Create and display the form */
    java.awt.EventQueue.invokeLater(new Runnable() {
        public void run() {

            new DragInitialListener().setVisible(true);

        }
    });
  }

// Variables declaration - do not modify                     
// End of variables declaration                   

   }

公共类Draginitialistener扩展了javax.swing.JFrame{
私人易变int draggedAtX，draggedAtY；
公共Draginitalistener（）{
初始化组件（）；
Droptargets（）；
Droptarget（）；
}
公共目标（）
{
DragListener d；
DragButton db=新的DragButton（）；
数据库设置大小（170140）；
d=新的减阻剂（db）；
DropTarget drop=新的DropTarget（此，d）；
this.getContentPane（）.add（db）；
}
公共目标（）
{
DragListener dd；
DragButton db1=新的DragButton（）；
db1.setSize（170140）；
dd=新的DragListener（db1）；
DropTarget drop1=新的DropTarget（此，dd）；
this.getContentPane（）.add（db1）；
}
//                           
私有组件（）{
setDefaultCloseOperation（javax.swing.WindowConstants.EXIT_ON_CLOSE）；
javax.swing.GroupLayout=newjavax.swing.GroupLayout（getContentPane（））；
getContentPane（）.setLayout（布局）；
layout.setHorizontalGroup(
createParallelGroup（javax.swing.GroupLayout.Alignment.LEADING）
.addGap（0，400，短。最大值）
);
layout.setVerticalGroup(
createParallelGroup（javax.swing.GroupLayout.Alignment.LEADING）
.addGap（0，300，短。最大值）
);
包装（）；
}//                         
公共静态void main（字符串参数[]）{
/*创建并显示表单*/
invokeLater（new Runnable（））{
公开募捐{
新Draginitialistener（）.setVisible（true）；
}
});
}
//变量声明-不修改
//变量结束声明
}

//这是DragListener课程

    public class DragListener extends JButton implements DropTargetListener     
    {

     JButton imagebutton = new JButton();
     //  JButton imagebutton1 = new JButton();

     private volatile int draggedAtX, draggedAtY;


      DragListener(JButton image) {

       imagebutton=image;

        }


         @Override
         public void dragEnter(DropTargetDragEvent dtde) {

          }

          @Override
           public void dragOver(DropTargetDragEvent dtde) {

            }

           @Override
            public void dropActionChanged(DropTargetDragEvent dtde) {


             }

            @Override
             public void dragExit(DropTargetEvent dte) {

             }

             @Override
             public void drop(DropTargetDropEvent ev) {

              ev.acceptDrop(DnDConstants.ACTION_COPY);
              Transferable t = ev.getTransferable();
               //DropTarget test = (DropTarget) ev.getSource();

                DataFlavor[] df= t.getTransferDataFlavors();
                 for(DataFlavor f:df)
               {
                try
                 {
                  if(f.isFlavorJavaFileListType())
                  {
                   List<File> files =(List<File>) t.getTransferData(f);

                    for(File file : files)
                     {
                       displayImage(file.getPath());
                        }
                      }
                       }
                       catch(Exception ex)
                          {
                           JOptionPane.showMessageDialog(null, ex);
                           }
                            }
                              }
                          private void displayImage(String path)
                         {
                         BufferedImage img = null;
                          try
                         {
                          img =ImageIO.read(new File(path));

                            }
                            catch(Exception e)
                            {

                              }
                            ImageIcon icon = new ImageIcon(img);
                            imagebutton.setIcon(icon);


                                  }



                               }

公共类DragListener扩展JButton实现DropTargetListener
{
JButton imagebutton=新JButton（）；
//JButton imagebutton1=新JButton（）；
私人易变int draggedAtX，draggedAtY；
DragListener（JButton图像）{
imagebutton=图像；
}
@凌驾
公共无效dragEnter（DropTargetDragEvent dtde）{
}
@凌驾
公共无效dragOver（DropTargetDragEvent dtde）{
}
@凌驾
公共无效dropActionChanged（DropTargetDragEvent dtde）{
}
@凌驾
公共无效dragExit（DropTargetEvent dte）{
}
@凌驾
公共空投（DropTargetDropEvent ev）{
ev.acceptDrop（DnDConstants.ACTION\u副本）；
可转移t=ev.getTransferable（）；
//DropTarget测试=（DropTarget）ev.getSource（）；
DataFlavor[]df=t.getTransferDataFlavors（）；
for（DataFlavor f:df）
{
尝试
{
if（f.isFlavorJavaFileListType（））
{
List files=（List）t.getTransferData（f）；
用于（文件：文件）
{
displayImage（file.getPath（））；
}
}
}
捕获（例外情况除外）
{
showMessageDialog（null，ex）；
}
}
}
私有void displayImage（字符串路径）
{
BuffereImage img=null；
尝试
{
img=ImageIO.read（新文件（路径））；
}
捕获（例外e）
{
}
ImageIcon图标=新的ImageIcon（img）；
imagebutton.setIcon（图标）；
}
}

简单开始，一个按钮可以工作，如果你能让一个按钮工作，你可以让100个按钮工作

这是一个非常简单的示例，它使用了传输API，因为您真正关心的是拖放而不是拖动

因此，只需更改布局并使用

public TestPane() {
    setLayout(new GridLayout(5, 5));
    for (int index = 0; index < 5 * 5; index++) {
        JButton btn = new JButton("Drop here");
        btn.setVerticalTextPosition(JButton.BOTTOM);
        btn.setHorizontalTextPosition(JButton.CENTER);
        btn.setTransferHandler(new ImageTransferHandler());
        add(btn);
    }
}

现在，您需要定义自己的规则，例如，当用户仅拖动单个图像时会发生什么？您是否每次都将其应用于第一个按钮（如我所做的），还是尝试查找没有图像的按钮并进行更新？如果所有按钮都有图像，会发生什么？那它去哪儿了

---

您是否拒绝具有两个以上图像的拖动？

简单开始，使用一个按钮，如果可以使用一个按钮，则可以使用100个按钮

这是一个非常简单的示例，它使用了传输API，因为您真正关心的是拖放而不是拖动

因此，只需更改布局并使用

public TestPane() {
    setLayout(new GridLayout(5, 5));
    for (int index = 0; index < 5 * 5; index++) {
        JButton btn = new JButton("Drop here");
        btn.setVerticalTextPosition(JButton.BOTTOM);
        btn.setHorizontalTextPosition(JButton.CENTER);
        btn.setTransferHandler(new ImageTransferHandler());
        add(btn);
    }
}

现在，您需要定义自己的规则，例如，当用户仅拖动单个图像时会发生什么？你把它应用到第一个但是

import java.awt.Component;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.GridBagLayout;
import java.awt.GridLayout;
import java.awt.Image;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.io.File;
import java.util.List;
import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.TransferHandler;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;

public class Test {

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

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

                JFrame frame = new JFrame("Testing");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.add(new TestPane());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public class TestPane extends JPanel {

        public TestPane() {
            setLayout(new GridBagLayout());

            JButton left = makeButton("Left");
            JButton right = makeButton("Right");

            add(left);
            add(right);

            setTransferHandler(new ImageTransferHandler(left, right));
        }

        protected JButton makeButton(String text) {
            JButton btn = new JButton(text);
            btn.setVerticalTextPosition(JButton.BOTTOM);
            btn.setHorizontalTextPosition(JButton.CENTER);
            return btn;
        }

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

    }

    public static class ImageTransferHandler extends TransferHandler {

        public static final DataFlavor[] SUPPORTED_DATA_FLAVORS = new DataFlavor[]{
            DataFlavor.javaFileListFlavor,};

        private JButton left, right;

        public ImageTransferHandler(JButton left, JButton right) {
            this.left = left;
            this.right = right;
        }

        @Override
        public boolean canImport(TransferHandler.TransferSupport support) {
            boolean canImport = false;
            for (DataFlavor flavor : SUPPORTED_DATA_FLAVORS) {
                if (support.isDataFlavorSupported(flavor)) {
                    canImport = true;
                    break;
                }
            }
            return canImport;
        }

        @Override
        public boolean importData(TransferHandler.TransferSupport support) {
            boolean accept = false;
            if (canImport(support)) {
                try {
                    Transferable t = support.getTransferable();
                    Image image = null;
                    if (support.isDataFlavorSupported(DataFlavor.javaFileListFlavor)) {
                        List files = (List) t.getTransferData(DataFlavor.javaFileListFlavor);
                        JButton buttons[] = new JButton[]{left, right};
                        for (int index = 0; index < Math.min(files.size(), 2); index++) {
                            if (files.size() > 0) {
                                image = ImageIO.read((File) files.get(index));
                                ImageIcon icon = null;
                                if (image != null) {
                                    icon = new ImageIcon(image);
                                }
                                buttons[index].setIcon(icon);
                            }
                        }
                        accept = true;
                    }
                } catch (Exception exp) {
                    exp.printStackTrace();
                }
            }
            return accept;
        }
    }
}