如何将文本输入从一个JTextField传递到另一个类中的变量？

Question

我正在尝试创建一个学生注册程序，其中用户在JTextField的JFrame中输入数据，并将该数据存储到另一个类的变量中。 包装注册；

import java.util.*;
/**
*
* @author Frank
*/
public class AcgRegistration {


public static void main(String[] args) {

    memberDialogBox memberDialogBox = new memberDialogBox();

}

}



    package acgregistration;

    /**
     *
     * @author Frank
     */
    class acgMember {
 private String name;
 private int num;
 private String email;

 public acgMember(String name, int number, String email) {
    this.name = name;
    this.num = number;
    this.email = email;
 }

 public String getName() {
    return name;
 }

 public void setName(String name) {
    this.name = name;
 }

 public int getNum() {
    return num;
 }

 public void setNum(int num) {
     this.num = num;
 }

 public String getEmail() {
    return email;
 }

 public void setEmail(String email) {
    this.email = email;
 }
 }



 package acgregistration;
 import javax.swing.*;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;

 /**
 *
 * @author Frank
 */
 public class memberDialogBox {

 String options[] = {"Student","Faculty/Staff"};
 JComboBox choices = new JComboBox(options);
 JButton b = new JButton("Confirm");
 JLabel l = new JLabel("Select your ACG Status");

 public memberDialogBox(){
  frame();
 }

 public void frame(){

  JFrame f = new JFrame();
  f.setVisible(true);
  f.setSize(210,150);
  f.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

  JPanel p = new JPanel();
  p.add(choices);
  p.add(b);
  p.add(l);

  f.add(p);

  b.addActionListener(new ActionListener(){
      public void actionPerformed(ActionEvent e){


          String s = choices.getSelectedItem().toString();
          if ("Student".equals(choices.getSelectedItem())){

               studentDialogBox student = new studentDialogBox();
    //This code gives me an error code saying I should call 
   //acgMemberModel


          }
          else{
                 facultyDialogBox faculty= new facultyDialogBox();
              }

        f.dispose();
          }

  });
  }

 }


 package acgregistration;
 import javax.swing.*;
 import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class studentDialogBox { 
private JTextField nameField = new JTextField("", 20);
private JTextField emailField = new JTextField("", 20);
private JTextField numberField = new JTextField("", 20);
private JButton confirmButton = new JButton("Confirm");
private acgMemberModel model;


public studentDialogBox(acgMemberModel model) {
    this.model = model;
    frame();
}



public void frame() {
    JFrame frame = new JFrame();
    frame.setVisible(true);
    frame.setSize(400, 400);
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    JPanel panel = new JPanel();
    panel.add(nameField);
    panel.add(emailField);
    panel.add(numberField);
    panel.add(confirmButton);
    frame.add(panel);

    confirmButton.addActionListener(new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            String name = nameField.getText();
            String number = numberField.getText();
            String email = emailField.getText();
            acgMember member = new acgMember(name, 
   Integer.valueOf(number), email);
            model.addNew(member);
        }
    });

   }
 }

class acgMemberModel {
private List<acgMember> members = new ArrayList<>();

public void addNew(acgMember member) {
    members.add(member);
}

public List<acgMember> getMembers() {
    return Collections.unmodifiableList(members);
}
}

我基本上是尝试对所有文本字段执行此操作，然后将其保存到ArrayList或Hashmap中（基本上是最终结果）。 我唯一的问题是，如何将文本输入从一类存储到另一类？ 任何帮助将不胜感激！ 谢谢！

Answer 1

每次您填充字段并按下此操作后，都会创建新的Member实例，此操作将导致监听器被调用，您将从文本字段中获取所有数据并将其传递给新的实例构造函数。 每次创建新成员时，将其传递给MemberModel单独的类。

PS，您需要阅读一些有关Java语言命名约定的知识，尤其是有关变量的知识，在将动作侦听器设置为TextField而不是Button时，您犯了错误，因为变量名完全没有意义。 我重构代码以将所有变量名更改为人类可读的形式，并解决了我的解决方案中的错误，因为尚未使用所有约定。

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Main {

    public static void main(String[] args) {
        MemberModel model = new MemberModel();
        StudentsToOutputListener outputListener
                = new StudentsToOutputListener(model, new FileOutput(new File("path to your default file")));
        Window studentDialog = new StudentDialogBox(model);
        Window facilityDialog = new FacultyDialogBox();
        Window memberDialog = new MemberDialogBox(studentDialog, facilityDialog);
        memberDialog.show();
    }
}

class Member {
    private String name;
    private int number;
    private String email;

    public Member(String name, int number, String email) {
        this.name = name;
        this.number = number;
        this.email = email;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    @Override
    public String toString() {
        return "Member{" +
                "name='" + name + '\'' +
                ", number=" + number +
                ", email='" + email + '\'' +
                '}';
    }
}

interface Window {
    void show();
}

interface Output {
    void output(List<Member> members);
}

interface Listener {
    void update();
}

class MemberDialogBox implements Window {
    private JFrame frame = new JFrame();
    private JComboBox<Window> choiceComboBox = new JComboBox<>();
    private JButton confirmButton = new JButton("Confirm");
    private JLabel selectLabel = new JLabel("Select your ACG Status");

    public MemberDialogBox(Window... windows) {
        for (Window window : windows) {
            choiceComboBox.addItem(window);
        }
        frame();
    }


    public void show() {
        frame.setVisible(true);
    }

    public void frame() {
        frame = new JFrame();
        frame.setSize(210, 150);
        frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        JPanel panel = new JPanel();
        panel.add(choiceComboBox);
        panel.add(confirmButton);
        panel.add(selectLabel);
        frame.add(panel);

        confirmButton.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {
                Window window = (Window) choiceComboBox.getSelectedItem();
                window.show();
                frame.dispose();
            }

        });
    }

}

class StudentDialogBox implements Window, Listener, Output {
    private JTextField nameField = new JTextField("", 20);
    private JTextField emailField = new JTextField("", 20);
    private JTextField numberField = new JTextField("", 20);
    private JButton confirmButton = new JButton("Confirm");
    private JButton saveButton = new JButton("Save students to file");
    private JFrame frame;
    private JList<Member> list = new JList<>();
    private MemberModel model;


    public StudentDialogBox(MemberModel model) {
        this.model = model;
        model.addListener(this);
        frame();
    }


    public void show() {
        frame.setVisible(true);
    }


    public void output(List<Member> members) {
        list.setListData(members.toArray(new Member[]{}));
    }


    public void update() {
        model.outputStudentsTo(this);
    }

    public void frame() {
        frame = new JFrame();
        frame.setSize(400, 400);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        JPanel panel = new JPanel();
        panel.add(nameField);
        panel.add(emailField);
        panel.add(numberField);
        panel.add(confirmButton);
        panel.add(list);
        panel.add(saveButton);
        frame.add(panel);

        saveButton.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {
                JFileChooser fileChooser = new JFileChooser();
                fileChooser.showSaveDialog(frame);
                File selectedFile = fileChooser.getSelectedFile();
                Output output = new FileOutput(selectedFile);
                model.outputStudentsTo(output);
            }
        });

        confirmButton.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {
                String name = nameField.getText();
                String number = numberField.getText();
                String email = emailField.getText();
                Member member = new Member(name, Integer.valueOf(number), email);
                model.addNewStudent(member);
            }
        });

    }


    public String toString() {
        return "Student";
    }
}

class FacultyDialogBox implements Window {

    public void show() {
        System.out.println("you need to implement FacultyDialogBox " +
                "in similar way than StudentDialog box");
    }


    public String toString() {
        return "Faculty/Stuff";
    }
}


class MemberModel {
    private List<Member> students = new ArrayList<>();
    private List<Member> stuff = new ArrayList<>();
    private List<Listener> listeners = new ArrayList<>();

    public void addListener(Listener listener) {
        listeners.add(listener);
    }

    private void notifyListeners() {
        for (Listener listener : listeners) {
            listener.update();
        }
    }

    public void addNewStudent(Member member) {
        students.add(member);
        notifyListeners();
    }

    public void addNewStuff(Member member) {
        stuff.add(member);
        notifyListeners();
    }

    public void outputStudentsTo(Output output) {
        output.output(Collections.unmodifiableList(students));
    }

    public void outputStuffTo(Output output) {
        output.output(Collections.unmodifiableList(stuff));
    }
}

class FileOutput implements Output {
    private final File destination;

    public FileOutput(File destination) {
        this.destination = destination;
    }

    public void output(List<Member> members) {
        try (BufferedWriter file = new BufferedWriter(new FileWriter(destination))) {
            for (Member member : members) {
                file.write(member.toString());
                file.write("\n");
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

}

class StudentsToOutputListener implements Listener {
    private final MemberModel model;
    private final Output output;

    public StudentsToOutputListener(MemberModel model, Output output) {
        this.model = model;
        this.output = output;
        model.addListener(this);
    }

    public void update() {
        model.outputStudentsTo(output);
    }
}

我更新了对您问题的澄清说明，我了解您要实现和修复您的程序的内容，还可以重构此代码，使其更加符合oop风格且更具可读性，但是您需要自己以类似方式实现第二个对话框工具比学生对话框。 另外，您需要将该源中的每个类放置到不同的* .java文件中。

Answer 2

您正在谈论数据绑定。 我最近发布了一个演示，演示了如何做您需要做的事情来回答这个问题： 切换JPanels对角移动内容

本质上，GUI通过事件（通常是属性更改事件）将信息传递给模型，反之亦然，但是您可以选择很多选项。 该过程如下所示：

1. 用户在字段中输入值
2. 失去焦点时，该字段会触发属性“值”的属性更改事件
3. GUI（或控制器类）侦听属性更改事件并触发另一个事件，例如Vetoable Change Event。
4. 模型（或控制器）侦听Vetoable的更改并验证该值，然后将“状态”保存在正确的位置。 如果验证失败，则将引发异常。
5. GUI检查否决例外，并在需要时还原该字段。

类似的方法可以允许模型将属性更改请求发送到GUI以更新字段的值。

使用这些事件的好处是，它使GUI保持简单，将模型与表示分离开来，并且更容易用另一种技术替换/复制GUI。

Answer 3

您是否尝试过将要在类之间共享的变量设置为public static ？