广泛使用Java泛型有什么缺点吗？

从技术角度来看，使用泛型（如下面的方法

createColumn（）

）有什么缺点吗？

public static <S, T> TableColumn<S, T> createColumn(final Class<S> sType, 
                                                    final Class<T> tType, 
                                                    final int minWidth, 
                                                    final Callback<TableColumn<S, T>, TableCell<S, T>> cellFactory) {
  TableColumn<S, T> tableColumn = new TableColumn<S, T>();

  tableColumn.setMinWidth(minWidth);
  tableColumn.setCellFactory(cellFactory);

  return tableColumn;
}

因为我有很多列，所以我想在工厂方法中结束创建，并将我的

createColumn（）

方法作为对象创建的单个点：

TableUtil.createColumn(Example.class, String.class, 100, myCellFactory);
TableUtil.createColumn(Other.cass, String.class, 50, myOtherFactory);

TableColumn<Example, String> colExample = TableUtil.createColumn(100, myCellFactory);
TableColumn<Other, String> colOther = TableUtil.createColumn(50, myOtherFactory);

这样创建工作很好，但是，我对

createColumn（）

中的所有泛型都感到有点不安全（可能是因为我还没有经常使用泛型）。这样做明智吗？或者这种方法是否有任何缺点或不安全

这样做明智吗？或者这种方法是否有任何缺点或不安全

---

你的代码没问题。泛型没有运行时成本，只存在于编译时。

泛型在这里只是为了帮助我们-正如您所知，它是一种编译时功能，用于检查我们正在使用的类型，并防止意外的

类异常

正如我所看到的，您没有使用传递的
类
对象，因此我会将您的方法重写为：

public static <S, T> TableColumn<S, T> createColumn(final int minWidth, 
                                                    final Callback<TableColumn<S, T>, 
                                                    TableCell<S, T>> cellFactory) {
  TableColumn<S, T> tableColumn = new TableColumn<S, T>();

  tableColumn.setMinWidth(minWidth);
  tableColumn.setCellFactory(cellFactory);

  return tableColumn;
}

public static TableColumn createColumn（final int minWidth，
最终回调（工厂）{
TableColumn TableColumn=新TableColumn（）；
tableColumn.setMinWidth（minWidth）；
tableColumn.setCellFactory（cellFactory）；
返回表列；
}

并会像这样调用它：

TableUtil.<Example, String>createColumn(100, myCellFactory);

TableUtil.createColumn（100，myCellFactory）；

没有必要用冗余的
类
参数来增加方法签名的负担，因为您只需指出泛型类型。
解决方案：在您给出了所有提示和建议之后，我就是这样结束了代码的

public static <S, T> TableColumn<S, T> createColumn(final int minWidth,
                                                    final Callback<TableColumn<S, T>, TableCell<S, T>> cellFactory) {
  TableColumn<S, T> tableColumn = new TableColumn<>();

  tableColumn.setMinWidth(minWidth);
  tableColumn.setCellFactory(cellFactory);

  return tableColumn;
}

public static TableColumn createColumn（final int minWidth，
最终回调（工厂）{
TableColumn TableColumn=新TableColumn（）；
tableColumn.setMinWidth（minWidth）；
tableColumn.setCellFactory（cellFactory）；
返回表列；
}

列创建：

TableUtil.createColumn(Example.class, String.class, 100, myCellFactory);
TableUtil.createColumn(Other.cass, String.class, 50, myOtherFactory);

TableColumn<Example, String> colExample = TableUtil.createColumn(100, myCellFactory);
TableColumn<Other, String> colOther = TableUtil.createColumn(50, myOtherFactory);

TableColumn colExample=TableUtil.createColumn（100，myCellFactory）；
TableColumn colOther=TableUtil.createColumn（50，myOtherFactory）；
在Java 8中，编译器将能够从（正确类型的）单元工厂实例推断类型，因此您应该能够只执行
TableUtil.createColumn（100，myCellFactory）
。哇，您是对的！我甚至没有注意到，我没有使用
类
对象。然而，在一些罕见的情况下，我将cellFactory设置为
null
，然后添加它。如果我省略了我的
sType
和
tType
属性，并将
cellFactory
设置为
null
，如果您将其分配给某个对象，您几乎肯定会这样做，因为您的方法没有副作用，编译器仍然可以根据您分配给它的变量的类型推断类型。例如，如果您执行
TableColumn col=createColumn（100，空）
编译器根据赋值推断
S
是
Person
，
T
是
String
。当然，这是非常有意义的。谢谢你指出这一点。此外，使用Java 7+可以在我的方法中使用菱形操作符，因此我可以将
TableColumn
初始化缩短为
TableColumn TableColumn=new TableColumn（）和Java也将在这里推断正确的类型。从技术上讲，由于类型擦除，您需要类参数来强制转换到X，可能还需要实例化X对象。类型擦除意味着没有开销，只是编译器有时可能会为泛型类型的已知实际类型值添加类强制转换检查。即使这样，当不使用泛型时，也需要手动类型检查。使用泛型对我们大家都是一种恩惠。软件工程的缺点是：它只作为类参数（1）实现，按照惯例，名称是一个大写字母（2），当传递给其他类时，会变得有点混乱。Java 8显示了这一点。为了确保这一点，我正确地理解了：如果我想执行
T obj=tType.newInstance（），我需要
Class
对象在我的方法中，对吗？因此，在我的例子中，我很可能可以删除这些参数，但感谢您的添加。是的，更好的编码实践是调用类默认构造函数：
tType.getConstructor（）
。但也
返回tType.cast（obj）有时是必需的。