java swing如何修复打印值的问题

我正在编写java swing，背包算法 我有四个参数，我想通过textfield获取值

n-->元素

重量-->重量

val-->值

W-->容量

应在标签java中打印

val

我的代码不会在标签中打印任何内容 我不知道为什么 没有错误

在我的代码中： 算法内部操作按钮“运行”

import java.awt.BorderLayout;
import java.awt.EventQueue;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import javax.swing.JButton;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import javax.swing.JTextField;
import javax.swing.JLabel;

import java.util.Scanner;
public class Knapsack_frame extends JFrame {
private JPanel contentPane;
private JTextField textField_4;
private JLabel lebel_out;
private JTextField textField;
private JTextField textField_1;
private JTextField textField_2;

/**
 * Launch the application.
 */
public static void main(String[] args) {
    EventQueue.invokeLater(new Runnable() {
        public void run() {
            try {
                Knapsack_frame frame = new Knapsack_frame();
                frame.setVisible(true);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    });
}

/**
 * Create the frame.
 */
public Knapsack_frame() {
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setBounds(100, 100, 871, 531);
    contentPane = new JPanel();
    contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
    setContentPane(contentPane);
    contentPane.setLayout(null);

    
    

    textField = new JTextField();
    textField.setColumns(10);
    textField.setBounds(408, 121, 213, 20);
    contentPane.add(textField);
    
    textField_1 = new JTextField();
    textField_1.setColumns(10);
    textField_1.setBounds(408, 149, 213, 20);
    contentPane.add(textField_1);
    
    textField_2 = new JTextField();
    textField_2.setColumns(10);
    textField_2.setBounds(408, 189, 213, 20);
    contentPane.add(textField_2);
    
    textField_4 = new JTextField();
    textField_4.setBounds(408, 228, 213, 20);
    contentPane.add(textField_4);
    textField_4.setColumns(10);

    
    //-----------------------------------------------------------------------------------------
    lebel_out = new JLabel("");
    lebel_out.setBounds(192, 289, 499, 52);
    contentPane.add(lebel_out);
    
    JLabel lblNewLabel = new JLabel("Enter number of elements :");
    lblNewLabel.setBounds(211, 124, 166, 14);
    contentPane.add(lblNewLabel);

    // here button run 
    JButton btnNewButton = new JButton("Knapsack Run");
    btnNewButton.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
             // here my algorithm Knapsack
             //four argement, input by text Filed 
            class Zero_One_Knapsack
            {
                public void solve(int[] wt, int[] val, int W, int N)
                {
                    int NEGATIVE_INFINITY = Integer.MIN_VALUE;
                    int[][] m = new int[N + 1][W + 1];
                    int[][] sol = new int[N + 1][W + 1];
                    for (int i = 1; i <= N; i++)
                    {
                        for (int j = 0; j <= W; j++)
                        {
                            int m1 = m[i - 1][j];
                            int m2 = NEGATIVE_INFINITY; 
                            if (j >= wt[i])
                                m2 = m[i - 1][j - wt[i]] + val[i];
                            m[i][j] = Math.max(m1, m2);
                            sol[i][j] = m2 > m1 ? 1 : 0;
                        }
                    }        
                    int[] selected = new int[N + 1];
                    for (int n = N, w = W; n > 0; n--)
                    {
                        if (sol[n][w] != 0)
                        {
                            selected[n] = 1;
                            w = w - wt[n];
                        }
                        else
                            selected[n] = 0;
                    }
                    
                    for (int i = 1; i < N + 1; i++)
                        if (selected[i] == 1)
                   
                lebel_out.setText("\nItems with weight "+ val[i] + "  " + "are selected by knapsack 
                 algorithm."  );
                }
                public void main (String[] args) 
                {
                   
                    Zero_One_Knapsack ks = new Zero_One_Knapsack();
             
                  int n = Integer.parseInt(textField.getText());
                    int[] wt = new int[n + 1];
                    int[] val = new int[n + 1];
             //----------------------------------------------------------------------
                    int valueWt =Integer.parseInt(textField_1.getText());
                    for (int i = 1; i <= n; i++)
                        wt[i] = valueWt;
            //-----------------------------------------------------------------------
                    int valueV =Integer.parseInt(textField_2.getText());
                    for (int i = 1; i <= n; i++)
                        val[i] =  valueV;
            //----------------------------------------------------------------------
                 
                    int W = Integer.parseInt(textField_4.getText());
                    ks.solve(wt, val, W, n);
                 
                }
            }
            
            
        }
    });
    btnNewButton.setBounds(355, 41, 192, 23);
    contentPane.add(btnNewButton);
    
    JLabel lblEnterWeightFor = new JLabel("Enter weight for 4 elements :");
    lblEnterWeightFor.setBounds(211, 152, 166, 14);
    contentPane.add(lblEnterWeightFor);
    
    JLabel lblEnterValueFor = new JLabel("Enter value for 4 elements :");
    lblEnterValueFor.setBounds(211, 189, 166, 14);
    contentPane.add(lblEnterValueFor);
    
    JLabel lblEnterCapacity = new JLabel("Enter capacity :");
    lblEnterCapacity.setBounds(211, 231, 166, 14);
    contentPane.add(lblEnterCapacity);
    
    
    
}
}

导入java.awt.BorderLayout；
导入java.awt.EventQueue；
导入javax.swing.JFrame；
导入javax.swing.JPanel；
导入javax.swing.border.EmptyBorder；
导入javax.swing.JButton；
导入java.awt.event.ActionListener；
导入java.awt.event.ActionEvent；
导入javax.swing.JTextField；
导入javax.swing.JLabel；
导入java.util.Scanner；
公共类背包_框架扩展JFrame{
私有JPanel内容窗格；
私有JTextField textField_4；
二等兵杰拉贝尔·勒贝尔·奥特；
私有JTextField textField；
私有JTextField textField_1；
私有JTextField textField_2；
/**
*启动应用程序。
*/
公共静态void main（字符串[]args）{
invokeLater（新的Runnable（）{
公开募捐{
试一试{
背包框架=新背包框架（）；
frame.setVisible（true）；
}捕获（例外e）{
e、 printStackTrace（）；
}
}
});
}
/**
*创建框架。
*/
公共背包框架（）{
setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
立根（100100871531）；
contentPane=newjpanel（）；
setboorder（新的EmptyBorder（5,5,5,5））；
setContentPane（contentPane）；
contentPane.setLayout（null）；
textField=新的JTextField（）；
textField.setColumns（10）；
textField.setBounds（408121213,20）；
contentPane.add（textField）；
textField_1=新的JTextField（）；
textField_1.设置列（10）；
textField_1.立根（408、149、213、20）；
contentPane.add（textField_1）；
textField_2=新的JTextField（）；
textField_2.设置列（10）；
textField_2.立根（408189213,20）；
contentPane.add（textField_2）；
textField_4=新的JTextField（）；
textField_4.立根（408228213,20）；
contentPane.add（textField_4）；
textField_4.设置列（10）；
//-----------------------------------------------------------------------------------------
lebel_out=新的JLabel（“”）；
lebel_out.挫折（192289499,52）；
contentPane.add（lebel_out）；
JLabel lblNewLabel=新JLabel（“输入元素数：”）；
lblNewLabel.立根（211、124、166、14）；
contentPane.add（lblNewLabel）；
//这里按钮运行
JButton btnNewButton=新JButton（“背包跑”）；
addActionListener（新ActionListener（）{
已执行的公共无效操作（操作事件e）{
//这是我的算法背包
//四个目标，通过文本字段输入
零级背包
{
公共void solve（int[]wt，int[]val，int W，int N）
{
int负无穷大=整数.MIN\u值；
int[][]m=新int[N+1][W+1]；
int[]sol=新int[N+1][W+1]；
对于（int i=1；i m1？1:0；
}
}        
选定的int[]=新int[N+1]；
对于（int n=n，w=w；n>0；n--）
{
如果（sol[n][w]！=0）
{
所选[n]=1；
w=w-重量[n]；
}
其他的
所选[n]=0；
}
对于（int i=1；i不要不必要地扩展
JFrame
不要使用
null
/
AbsoluteLayout
在这里查看一些选项
不要在组件上手动调用
setBounds
，使用
LayoutManager
让组件自行调整大小，只需在
JFrame上调用
pack（）

不要调用
JFrame
的
setContentPane
来简单地添加
JPanel
，或者调用
JFrame\getContentPane（）
或者简单地调用
JFrame\add（…）
，也许这是我的偏好
您的类名不是Java中常见的名称（下划线为小写字母），它们应该是Pascal大小写，即
KnapsackApp
，
ZeroOneKnapsack
无下划线等。尽管其有效性不是正常惯例
这同样适用于变量名（textField_1），通常是驼峰式的，即
textField1
，也可能最好给它们起更好的名字，即
elementsLabel
分离您的关注点，您有一个嵌套在
JButton
s
actionPerformed
（我假设访问
JTextField
s等，但这不是必需的），在单独的文件中创建它，将参数传递给
solve
方法并返回结果，然后使用该结果设置结果
JLabel
值
<
String line = "1,2,3,1,2,2,1,2,3,"; // example from textFeild.getText()
int[] numbers = Arrays.stream(line.split(",")).mapToInt(Integer::parseInt).toArray();

import java.awt.event.ActionEvent;
import java.util.concurrent.ExecutionException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.SwingUtilities;
import javax.swing.SwingWorker;
import javax.swing.border.EmptyBorder;

public class KnapsackApp {

    public KnapsackApp() {
        initComponents();
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(KnapsackApp::new);
    }

    private void initComponents() {
        JFrame frame = new JFrame();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        // setup JPanel and LayoutManager
        JPanel panel = new JPanel();
        panel.setBorder(new EmptyBorder(5, 5, 5, 5));
        panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));

        JLabel elementsLabel = new JLabel("Enter number of elements :");
        panel.add(elementsLabel);
        JTextField elementsTextField = new JTextField();
        elementsTextField.setColumns(10);
        panel.add(elementsTextField);

        JLabel lblEnterWeightFor = new JLabel("Enter weight for 4 elements :");
        panel.add(lblEnterWeightFor);
        JTextField weightTextField = new JTextField();
        weightTextField.setColumns(10);
        panel.add(weightTextField);

        JLabel lblEnterValueFor = new JLabel("Enter value for 4 elements :");
        panel.add(lblEnterValueFor);
        JTextField valueTextFields = new JTextField();
        valueTextFields.setColumns(10);
        panel.add(valueTextFields);

        JLabel lblEnterCapacity = new JLabel("Enter capacity :");
        panel.add(lblEnterCapacity);
        JTextField capacityTextField = new JTextField();
        panel.add(capacityTextField);
        capacityTextField.setColumns(10);

        JLabel resultLabel = new JLabel("Result: ");
        panel.add(resultLabel);

        JButton btnNewButton = new JButton("Knapsack Run");
        panel.add(btnNewButton);

        btnNewButton.addActionListener((ActionEvent e) -> {
            int n = Integer.parseInt(elementsTextField.getText());
            int[] wt = new int[n + 1];
            int[] val = new int[n + 1];

            int valueWt = Integer.parseInt(weightTextField.getText());
            for (int i = 1; i <= n; i++) {
                wt[i] = valueWt;
            }
            int valueV = Integer.parseInt(valueTextFields.getText());
            for (int i = 1; i <= n; i++) {
                val[i] = valueV;
            }

            int W = Integer.parseInt(capacityTextField.getText());

            SwingWorker backgroundWorker = new SwingWorker<Integer, Void>() {
                @Override
                public Integer doInBackground() throws Exception {
                    // do the work
                    return new ZeroOneKnapsack().solve(wt, val, W, n);
                }

                @Override
                protected void done() {
                    int result;
                    try {
                        // get and display the result from solve
                        result = get();
                        resultLabel.setText("Result: " + result);
                    } catch (InterruptedException | ExecutionException ex) {
                        Logger.getLogger(KnapsackApp.class.getName()).log(Level.SEVERE, null, ex);
                    }
                }
            };
            backgroundWorker.execute();
        });

        frame.add(panel);
        frame.pack();
        frame.setVisible(true);
    }

}

public class ZeroOneKnapsack {

    public int solve(int[] wt, int[] val, int W, int N) {
        int NEGATIVE_INFINITY = Integer.MIN_VALUE;
        int[][] m = new int[N + 1][W + 1];
        int[][] sol = new int[N + 1][W + 1];
        for (int i = 1; i <= N; i++) {
            for (int j = 0; j <= W; j++) {
                int m1 = m[i - 1][j];
                int m2 = NEGATIVE_INFINITY;
                if (j >= wt[i]) {
                    m2 = m[i - 1][j - wt[i]] + val[i];
                }
                m[i][j] = Math.max(m1, m2);
                sol[i][j] = m2 > m1 ? 1 : 0;
            }
        }
        int[] selected = new int[N + 1];
        for (int n = N, w = W; n > 0; n--) {
            if (sol[n][w] != 0) {
                selected[n] = 1;
                w = w - wt[n];
            } else {
                selected[n] = 0;
            }
        }

        for (int i = 1; i < N + 1; i++) {
            if (selected[i] == 1) {
                return val[i];
            }
        }

        return -1;
    }
}