Java泛型，把T方法称为T而不是它的超类 [英] Java generics, call T method as T and not as its superclass

问题描述

在java中我有以下伪代码：

  class MyClassSuper {
 public static final String VALUE = E; 
} 
 
 class MyClassSub扩展MyClassSuper {
 public static final String VALUE =f; 
} 
 
 class MyGenericClass< T extends MyClassSuper> {
 public void print（）{
 System.out.println（T.VALUE）; 
 
 
 $ / code> 

当我使用MyClassSub创建MyGenericClass的新实例时它的类型我期望打印方法打印f，但它打印e。是否有可能让MyGenericClass把T当作它的实际类型，同时保持当前T扩展的超类？

编辑：

实际代码（缩写）：

  public class Bean implements Serializable { 
 
 public static final String FILE_EXT =; 
 private static final long serialVersionUID = 1L; 
 
 
 
 public class UserBean extends Bean {
 
 public static final String FILE_EXT =u; 
 private static final long serialVersionUID = 1L; 
 
私人字符串名称; 
 
 public UserBean（String name）{
 this.name = name; 
} 
} 
 
 public class BeanPersistence< T extends Bean>实现IBeanPersistence< T> {
 
 public void printExtension（）{
 System.out.println（T.FILE_EXT）; 
} 
 
} 
  

这是我的代码试图写。基本上，我想让BeanPersistence类根据它初始化的Bean的类型知道它正在写入的文件使用什么扩展名。从我收集的意见来看，这是做这件事的错误方式，什么是适当的方式？ （很明显，printExtension方法只是用于测试）

解决方案

根据您的情况，这可能是合适的。

  public class BeanPersistence< T extends Bean> {
 
 public void printExtension（Bean bean）{
 System.out.println（bean.getExtension（））; 
 
 
 public static void main（String [] args）{
 
 BeanPersistence< Bean> persistence = new BeanPersistence<>（）; 
 UserBean userBean = new UserBean（）; 
 AdminBean adminBean = new AdminBean（）; 
 persistence.printExtension（userBean）; //打印u 
 persistence.printExtension（adminBean）; //打印
} 
} 
 
抽象类Bean {
 
 abstract String getExtension（）; 
} 
 
类UserBean扩展Bean {
 
 private static final String FILE_EXT =u; 
 
 @Override 
 String getExtension（）{
 return FILE_EXT; 
 
 
 
类AdminBean扩展Bean {
 
 private static final String FILE_EXT =a; 
 
 @Override 
 String getExtension（）{
 return FILE_EXT; 
 
 
 
 
 $ b一般而言，你应该通过访问对象属性，方法，而不是直接。当我们调用方法时，面向对象的行为（多态，动态调度）将调用正确的方法。
 
 
 
另见
 
 
 
 
 
 多态性  li> 
 
 隐藏字段（错误！）
 
 
 
I have the following pseudo-code in java:
class MyClassSuper{
    public static final String VALUE = "e";
}

class MyClassSub extends MyClassSuper{
    public static final String VALUE = "f";
}

class MyGenericClass<T extends MyClassSuper> {
    public void print(){
        System.out.println(T.VALUE);
    }
}
When I create a new instance of MyGenericClass with MyClassSub as its type I'm expecting the print method to print "f", but it prints "e" instead. Is it possible to have MyGenericClass treat T as the actual type that it is while keeping the super class that T extends currently ?

EDIT:

Actual code (abbreviated):
public class Bean implements Serializable {

    public static final String FILE_EXT = "";
    private static final long serialVersionUID = 1L;

}

public class UserBean extends Bean{

    public static final String FILE_EXT = "u";
    private static final long serialVersionUID = 1L;

    private String name;

    public UserBean(String name){
        this.name = name;
    }
}

public class BeanPersistence<T extends Bean> implements IBeanPersistence<T> {

    public void printExtension(){
        System.out.println(T.FILE_EXT);
    }

}
That is the code I'm trying to write. Basicly I want the BeanPersistence class to know what extension to use for the file it is writing, based on the type of Bean it was initialized with. From the comments I gather this is the wrong way of doing this, what would be the appropriate way ? (Obviously the printExtension method is just there to test)
解决方案
This might be suitable, depending on your case.
public class BeanPersistence<T extends Bean> {

    public void printExtension(Bean bean) {
        System.out.println(bean.getExtension());
    }

    public static void main(String[] args) {

        BeanPersistence<Bean> persistence = new BeanPersistence<>();
        UserBean userBean = new UserBean();
        AdminBean adminBean = new AdminBean();
        persistence.printExtension(userBean); // prints u
        persistence.printExtension(adminBean); // prints a
    }
}

abstract class Bean {

    abstract String getExtension();
}

class UserBean extends Bean {

    private static final String FILE_EXT = "u";

    @Override
    String getExtension() {
        return FILE_EXT;
    }
}

class AdminBean extends Bean {

    private static final String FILE_EXT = "a";

    @Override
    String getExtension() {
        return FILE_EXT;
    }
}
In general you should access object properties through methods, not directly. When we call methods, object-oriented behaviour (polymorphism, dynamic dispatch) will invoke the right method.

See also


Polymorphism
Hiding Fields (bad!)


                        
这篇关于Java泛型，把T方法称为T而不是它的超类的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！