我有一个问题是在我的班级中使用泛型.这些是我的课程:
public interface InterE<PK> {}
public interface Inter2<O extends ClassO, P extends ClassP> {}
public class ClassU<O extends ClassO, P extends ClassP> implements InterE<Long> {}
public class ClassP {}
public class ClassO {}
public class Class1<PK, T extends InterE<PK>> {
public Class1 (Class<T> clazz) {}
}
public class Class2<O extends ClassO, P extends ClassP> extends Class1<Long, ClassU<O, P>> implements Inter2<O, P> {
public Class2 () {
//old constructor
//super(ClassU.class);
//new - here is problem
super(ClassU<O, P>.class);
}
}
如果ClassU不使用泛型,那么Class2中的旧构造函数工作正常,但我需要在ClassU中使用泛型,所以我在Class2中调用超级构造函数时遇到问题.
我有一个通用的功能界面:
@FunctionalInterface
public interface Feeder<T extends Animal> {
void feed(T t);
}
还有一些bean为不同的Animal子类实现了这个接口.
@Configuration
public class Config {
@Bean
public Feeder<Dog> dogFeeder() {
return dog -> dogService.feedDog(dog);
}
@Bean
public Feeder<Cat> catFeeder() {
return cat -> catService.feedCat(cat);
}
}
现在已经为这些bean注入了一个服务类,并给出了一个实例Animal.如何确定使用正确的Feeder bean？
@Service
public class PetStore {
@Autowired
private List<Feeder<? extends Animal> feeders;
private void feed(Animal animal) {
//TODO: How to determine the correct feeder from feeders?
Feeder<? extends Animal> correctFeeder = ....
correctFeeder.feed(animal);
}
}
我试过的事情:
我最初认为我可以使用如何获取泛型类型T的类实例, …
考虑以下通用转换器类（为简洁起见，已简化/不完整）...
public abstract class BaseConverter <TModel>
{
public void convert(String data, Class<TModel> classOfModelType)
{
}
public void convert(String data)
{
convert(data, TModel.class); // This doesn't work!
}
}
在子类外部，我可以convert毫无问题地调用第一个。将此子类视为Car泛型类型参数。我可以进去Car.class，像这样...
public class CarConverter extends BaseConverter<Car>
{
public void someFunction()
{
String someString;
convert(someString, Car.class);
}
}
我想做的就是尽可能多地移动到基类。由于 'Car' 在这里是已知的，因此convert需要Car.class, 并在基类中TModel表示Car（无论如何对于这个具体的 BaseConverter ），我试图TModel.class在基类中使用，但如上所述，它不起作用。
那么如何在 Java 中实现这一点呢？
我有一个方法返回一个List<Property<?>>.
属性是具有一个通用参数的类型:
public class Property<T extends Comparable<T>> { ... }
有一个混合类型属性的列表,我不知道具体元素具有什么类型参数.
我想做那样的事情:
List<Property<?>> list = getList();
for(Property<?> crt : list)
{
PropertyWrapper<?> crtWrapper = new PropertyWrapper(crt.getGenericType());
// I know this doesn't exist ----^
}
在一句话中:我需要PropertyWrapper具有与当前相同的通用模板参数Property.有没有办法做到这一点？
我可以应用/sf/answers/240655131/中所述的建议,但即使我这样做,如何实现适当的,PropertyWrapper<XXX>然后只有一个实例Class<T>？
Property<?>如果需要,我可以修改.我也不介意是否需要使用反射(我认为它需要)
编辑:我忘记了什么.事实上,我无法通过线路实现包装
PropertyWrapper<?> crtWrapper = new PropertyWrapper(crt.getGenericType());
因为我有专门的子类(PropertyWrapper_String).
现在我看到两种可能性:
1:按字符串对类进行Instanciate:
String strGenericType = "";
Class<?> wrapperClass = Class.forName("PropertyWrapper_" + strGenericType);
2:有没有办法在不创建子类的情况下专门化泛型类？
非常感谢您的提示
我写了这段代码:
public static <T> void getList(Vector<T> result){
System.out.println(result.getClass().getName());
}
我想写出类名T,但我无法得到它.我怎样才能做到这一点？
想象一下有一个java类
public class FixedClassOfStrings {
List<String> myMember=new ArrayList<String>();
// omissed all non relevant code...
public Class getMyType() {
return String.class;
}
}
如何通过使用 java 泛型使其参数化？
我的尝试失败了：
public class GenericClass<T> {
List<T> myMember=new ArrayList<T>();
public Class getMyType() {
return T.class; // this gives "Illegal class literal for the type parameter T"
}
}
另外，如何避免在 FixedClassOsStrings 中发出警告：“类是原始类型。对泛型类的引用应该参数化”？可以声明：
public Class<String> getMyType() {
return String.class;
}
...
如果没问题，我应该使用泛型返回什么？
public Class<T> getMyType() {
return T.class; // this gives "Illegal class literal for the type parameter …我已经找到了一些关于如何使用泛型构建Hibernate DAO的教程,但它们都使用EntityManager而不是使用SessionFactory.我的问题是如何使用泛型构建DAO SessionFactory.到目前为止我有以下内容:
接口:
public interface GenericDao<T> {
public void save(T obj);
public void update(T obj);
public void delete(T obj);
public T findById(long id);
}
类:
@Repository
public class GenericDaoImpl<T> implements GenericDao<T> {
@Autowired
private SessionFactory sessionFactory;
public void save(T obj) {
Session session = sessionFactory.openSession();
Transaction tx = null;
try {
tx = session.beginTransaction();
session.save(obj);
tx.commit();
} catch (HibernateException e) {
if(tx != null)
tx.rollback();
e.printStackTrace();
} finally {
session.close();
}
}
public void …请考虑以下代码:
public class Context {
private final Class<?> clazz;
private final String resource;
private final com.thirdparty.Context context;
public Context(final String resource, final Class<?> clazz) {
this.clazz = clazz;
this.resource = resource;
this.context = com.thirdparty.Context.newInstance(this.clazz);
}
public String marshall(final Object element) {
return this.context.marshall(element);
}
public Object unmarshall(final String element) {
return this.context.unmarshall(element);
}
}
Context context = new Context("request.xsd", Request.class);
// Marshall
Request request = new Request();
String xml = context.marshall(request);
// Unmarshall
Request roundTrip = Request.cast(context.unmarshall(xml));
我试图用泛类版本的Context类替换它:
public class …我尝试使用下一个方法:
fun <T> put(value: T){
val clazz = T::class.java
}
但有例外 Kotlin: Only classes are allowed on the left hand side of a class literal
如何从泛型参数获取类？
除了类之外还有哪些其他选项可以作为参数传递？
我在代码中面临一个令人困惑的问题。
我有一种方法是签名
public <T extends Measure> void sendNewMeasure(Class<T> type, T measure);
在另一个类中，我有此方法，该方法调用上一个方法：
public <T extends Measure> void onNewMeasure(NewMeasureEvent<T> event) {
T measure = event.getMeasure();
APIInterface.getInstance().sendNewMeasure(measure.getClass(), measure);
}
我得到的错误是Wrong argument type, found 'T', required <? extends com.blablabla.Measure>但我不明白为什么，因为测量对象的类型为T，扩展了Measure。
有什么办法可以解决此问题，最重要的是，为什么它不起作用？
谢谢 ！
编辑：
这是sendNewMeasure方法的实现：
public <T extends Measure> void sendNewMeasure(Class<T> type, T measure) {
String measureType = measure.getJSONMeasureTypeName();
List<T> measures = T.find(type, measure.timestamp, true, false);
measures.add(measure);
sendMeasures(siteId, sensorId, measureType, measures);
}
编辑2：这是find方法签名，我无法更改：
public static <T> List<T> find(Class<T> type, int timestamp, boolean …我的用例是编写一个通用的 CSV 转换器，它应该能够将任何 Java POJO 转换为 CSV 字符串。
我的实现：
public <T> List<String> convertToString(List<T> objectList) {
List<String> stringList = new ArrayList<>();
char delimiter = ',';
char quote = '"';
String lineSep = "\n";
CsvMapper mapper = new CsvMapper();
CsvSchema schema = mapper.schemaFor(!HOW_TO!);
for (T object : objectList) {
try {
String csv = mapper.writer(schema
.withColumnSeparator(delimiter)
.withQuoteChar(quote)
.withLineSeparator(lineSep)).writeValueAsString(object);
} catch (JsonProcessingException e) {
System.out.println(e);
}
}
return stringList;
}
我正在使用 Jackson-dataformat-csv 库，但我坚持使用 !HOW_TO！部分，即如何从objectList中提取对象的.class。我正在学习并遇到了类型擦除，所以我认为除了将 .class 作为我的函数的参数之外，这是不可能的。但我也使用 Java 反射从通用实体中提取此对象列表，因此我无法选择提供 .class 参数。
有解决方法吗？
或者
我可以转换具有 …
java csv generics jackson-dataformat-csv amazon-kinesis-firehose
我正在尝试通过JAXB创建一个用于去/序列化的泛型类.在创建JAXBContext类时必须传入,但当然使用泛型类,这是事先不知道的.
所以当我尝试这个时,我当然会得到一个编译错误.
public class ServerSerializing<T>
{
private JAXBContext mJAXBContext = null;
public JAXBContext getJAXBContext()
{
if(mJAXBContext == null)
mJAXBContext = JAXBContext.newInstance(T.class);
return mJAXBContext;
}
}
结果是:
Illegal class literal for the type parameter T
那么通过通用方法可以做到这一点吗？