我的目标是简单地编辑树视图的单元格（为此，我已经阅读了JavaFX的文档）。
我的问题是我的树视图不包含strings ，而是我自己的数据类型，即：{{1} }。我收到了错误：Database。
是否可以使用我自己的类型实现树视图？
这是我在James_D的帮助下使用的代码：
Database$Variable cannot be cast to core.Database这是我的DataBase类：
public class DatabaseStructureView extends TreeView<Object> {
private Database db;
@FXML
private TreeView<Database> databaseStructureView;
public DatabaseStructureView() {
FXMLLoader fxmlLoader = new FXMLLoader(getClass().getResource("DatabaseStructureView.fxml"));
fxmlLoader.setRoot(this);
fxmlLoader.setController(this);
try {
fxmlLoader.load();
} catch (IOException exception) {
throw new RuntimeException(exception);
}
databaseStructureView.setEditable(true);
databaseStructureView.setCellFactory(new Callback<TreeView<Database>,TreeCell<Database>>(){
@Override
public TreeCell<Database> call(TreeView<Database> param) {
return new TextFieldTreeCellImpl();
}
});
}
private final class TextFieldTreeCellImpl extends TreeCell<Database> {
private TextField textField;
public TextFieldTreeCellImpl() {
}
@Override
public void startEdit() {
super.startEdit();
if (textField == null) {
createTextField();
}
setText(null);
setGraphic(textField);
textField.selectAll();
}
@Override
public void cancelEdit() {
super.cancelEdit();
setText(getString());
setGraphic(getTreeItem().getGraphic());
}
@Override
public void updateItem(Database item, boolean empty) {
super.updateItem(item, empty);
if (empty) {
setText(null);
setGraphic(null);
} else {
if (isEditing()) {
if (textField != null) {
textField.setText(getString());
}
setText(null);
setGraphic(textField);
} else {
setText(getString());
setGraphic(getTreeItem().getGraphic());
}
}
}
private void createTextField() {
textField = new TextField(getString());
textField.setOnKeyReleased(new EventHandler<KeyEvent>() {
@Override
public void handle(KeyEvent t) {
if (t.getCode() == KeyCode.ENTER) {
commitEdit(getDatabase(textField.getText()));
} else if (t.getCode() == KeyCode.ESCAPE) {
cancelEdit();
}
}
});
}
private Database getDatabase(String text) {
return new Database(text);
}
private String getString(){
return getItem() == null ? "" : getItem().toString();
}
}
public void setDatabase(Database db) {
this.db = db;
TreeItem<Object> dbRoot = new TreeItem<>(db);
dbRoot.setExpanded(true);
for (Variable var : db.getVariables()) {
dbRoot.getChildren().add(new TreeItem<Object>(var));
}
setRoot(dbRoot);
}
}
}
以下是我得到的错误：
public class Database {
public static class Variable {
public static enum VariableType {
NUMERIC, INTEGER, LOGIC, ORDONEE, NOMINAL, DATE
}
private String name;
private VariableType type;
private List<String> values;
public Variable(String name) {
this.name = name;
values = new ArrayList<>();
}
private void addValue(String value) {
values.add(value);
}
public String getValue(int index) {
return values.get(index);
}
public void addValue(int index, String value) {
values.add(index, value);
}
public VariableType getType() {
return type;
}
public String getName() {
return name;
}
public List<String> getValues() {
return values;
}
public String calculerMinimum (){
if(this.getType().equals(VariableType.INTEGER)){
// Je convertit en entier les strings
List<String> maColonneString = this.getValues();
List<Integer> maColonneInt = new ArrayList<Integer>();
for(int i = 0; i < maColonneString.size(); i++){
if(!maColonneString.get(i).equals("NULL")){
maColonneInt.set(i, Integer.parseInt(maColonneString.get(i)));
}
}
return(Integer.toString(Collections.min(maColonneInt)));
}
else {
return null;
}
}
public String calculerMaximum (){
if(this.getType().equals(VariableType.INTEGER)){
// Je convertit en entier les strings
List<String> maColonneString = this.getValues();
List<Integer> maColonneInt = new ArrayList<Integer>();
for(int i = 0; i < maColonneString.size(); i++){
if(!maColonneString.get(i).equals("NULL")){
maColonneInt.set(i, Integer.parseInt(maColonneString.get(i)));
}
}
return(Integer.toString(Collections.max(maColonneInt)));
}
else {
return null;
}
}
public String calculerFrequence (String maValeurTemoin){
List<String> maColonneString = this.getValues();
int compteur = 0;
for(int i = 0; i < maColonneString.size(); i++){
if(maColonneString.get(i).equals(maValeurTemoin)){
compteur ++;
}
}
return Integer.toString(compteur);
}
public String calculerMoyenne (){
if(this.getType().equals(VariableType.INTEGER)){
List<String> maColonneString = this.getValues();
int somme = 0;
int valeurNull=0;
for(int i = 0; i < maColonneString.size(); i++){
if(!maColonneString.get(i).equals("NULL")){
somme += Integer.parseInt(maColonneString.get(i));
}
else{
valeurNull ++;
}
}
return (Integer.toString(somme/(maColonneString.size()-valeurNull)));
}
else {
return null;
}
}
public String calculerVariance (){
if(this.getType().equals(VariableType.INTEGER)){
List<String> maColonneString = this.getValues();
int sommeMul=0;
int variance=0;
int valeurNull=0;
for(int i = 0; i < maColonneString.size(); i++){
if(!maColonneString.get(i).equals("NULL")){
sommeMul += Integer.parseInt(maColonneString.get(i))*Integer.parseInt(maColonneString.get(i));
}
else{
valeurNull ++;
}
}
variance = sommeMul/(maColonneString.size()-valeurNull)-Integer.parseInt(calculerMoyenne())*Integer.parseInt(calculerMoyenne());
return Integer.toString(variance);
}
else {
return null;
}
}
public String calculerEcartType (){
if(this.getType().equals(VariableType.INTEGER)){
return (Double.toString( Math.sqrt(Integer.parseInt(calculerVariance()))));
}
else {
return null;
}
}
public List<String> calculerAnalyseUnivarieRestreinte (){
if(this.getType().equals(VariableType.INTEGER)){
List<String> analyseUniList = new ArrayList<String>();
analyseUniList.add(calculerMinimum());
analyseUniList.add(calculerMaximum());
analyseUniList.add(calculerMoyenne());
return analyseUniList;
}
else{
return null;
}
}
public List<String> calculerAnalyseUnivarieComplete (){
if(this.getType().equals(VariableType.INTEGER)){
List<String> analyseUniList = new ArrayList<String>();
analyseUniList.add(calculerMinimum());
analyseUniList.add(calculerMaximum());
analyseUniList.add(calculerMoyenne());
analyseUniList.add(calculerVariance());
analyseUniList.add(calculerEcartType());
return analyseUniList;
}
else{
return null;
}
}
public boolean rechercherValeur (String maValeurTemoin){
List<String> maColonneString = this.getValues();
return(maColonneString.contains(maValeurTemoin));
}
public void setTypeVariable (VariableType monNouveauType){
this.type = monNouveauType;
}
public void setNomVariable (String monNouveauNom){
this.name = monNouveauNom;
}
public void modifierValeur (String ancienneValeur, String nouvelValeur){
List<String> maColonneString = this.getValues();
for(int i = 0; i < maColonneString.size(); i++){
if(maColonneString.get(i).equals(ancienneValeur)){
this.values.set(i, nouvelValeur);
}
}
}
@Override
public String toString() {
return name;
}
}
private List<Variable> variables;
private String name;
public Database(String name) {
this.name = name;
variables = new ArrayList<>();
}
public void addVariable(String name) {
variables.add(new Variable(name));
}
public String print() {
StringBuilder sb = new StringBuilder();
int i = 0;
while (i != variables.get(0).values.size()) {
for (Variable variable : variables) {
sb.append(variable.values.get(i)).append(" ");
}
sb.append(System.getProperty("line.separator"));
i++;
}
return sb.toString();
}
@Override
public String toString() {
return name;
}
public Variable getVariable(Variable maVariable) {
for (Variable variable : variables) {
if (variable.getName().equals(maVariable.getName())) {
return variable;
}
}
return null;
}
public List<Variable> getVariables() {
return new ArrayList<>(variables);
}
public Variable getVariable(int index) {
return variables.get(index);
}
public boolean addVariable(Variable variableAdd) {
return (this.variables.add(variableAdd));
}
public boolean removeVariable(Variable variableRemove) {
return (this.variables.remove(variableRemove));
}
答案 0 :(得分：1)
您发布的代码有一个奇怪的结构：您有两个TreeView引用，TreeView<Object>子类（DatabaseStructureView）的实例，它被设置为FXML的动态根，然后是您声明的TreeView<Database>引用：databaseStructureView。
根据您的描述，我只能假设（因为您没有创建MCVE），您已通过设置fx:id属性将这两个引用分配给同一个对象根，如下：
<fx:root type="TreeView" fx:id="databaseStructureView" ... >
所以这里发生的是this（在DatabaseStructureView）和databaseStructureView的上下文中都指向同一个对象。
这是一个非常令人困惑的设置，你不应该这样做。 （具体而言，当根也是控制者时，不要在fx:id上设置<fx:root ... >。）
发生的事情大致如下：
在某处您可以执行类似
的操作TreeView<Object> treeView = new DatabaseStructureView<>();
这会导致加载fxml加载程序。因为你setRoot(this)，它实际上是
Object root = treeView ;
（类型为Object，因为FXML实际上是无类型的）。然后，因为您有setController(this)，FXMLLoader的控制器也设置为treeView。然后，当它解析FXML时，它会看到fx:id并将databaseStructureView设置为treeView。所以你实际上有treeView.databaseStructureView == treeView。您可以通过添加
System.out.println(this == databaseStructureView);
FXMLLoader load()方法后的。
由于类型擦除，并且因为FXMLLoader的所有赋值都是通过反射进行的，所以泛型类型是不可见的，因此FXML根目录的编译时类型为TreeView<Object>和{ {1}}的编译时类型为databaseStructureView，两者都具有原始TreeView<Database>的运行时类型。所以这些反思任务都是成功的。
但是发生的事情是，通过在FXML加载器中使用反射，您现在已经进行了非类型安全的分配，因此对泛型类型的所有赌注都是关闭的。由于TreeView的编译时类型为databaseStructureView，因此编译器认为可以安全地假设该树中的所有树项都必须为TreeView<Database>。因此，您的TreeItem<Database>方法会将updateItem(...)作为参数。但是，由于当前对象是Database，编译器将允许您向树结构添加任何TreeView<Object>。但是，因为他们指的是同样的事情，当你做
TreeView<Object>您要在dbRoot.getChildren().add(new TreeItem<Object>(var));
的树结构中添加TreeView<Object>。当树视图稍后检索包装对象（实际上是databaseStructureView）并将其传递给DatabaseStructure.Variable方法时，会得到类转换异常，因为它是错误的类型。
这显然很令人困惑：虽然混淆来自于不必要的引用updateItem(...)，它与当前对象完全相同。如果您完全删除该引用以及databaseStructure属性，那么您只需将fx:id的任何引用替换为databaseStructureView即可。然后会发生的是，您在编译时检测到的类型错误，而不是在运行时（它不会让您将this设置为单元工厂，例如现在（正确）期望Callback<TableView<Database>, TableCell<DataBase>>。
阻止您执行所需操作的根本问题是Callback<TableView<Object>, TableCell<Object>>中的所有项都必须是同一类型。您正在尝试混合类型：某些TreeView包含TreeItem个对象，其他包含Database个对象。您需要设计对象模型以使所有内容都具有公共类型，或者将单元格实现编写为Database.Variable并以某种方式确定在提交编辑时要创建的正确对象。