java 泛型高手请进来看一下

Question

手上有一段这样的C#代码要转换成java代码，因之前未接触过java，对一些语法还不是很清楚，现在已写了一个这样的泛型函数：public static <T> List<T> Parse(byte[] data)  //T 将是在另外定义的所有继承基类BaseBlob的子类的泛型参数
{
  List<T> series = new ArrayList<T>();
 
  
  已知所有继承基类BaseBlob的子类都有一个成员叫attrList（基类本身也有这个成员）类型是ArrayList型          在这要把这个传进来的泛型参数T 的这个成员值取出来          语法上该怎么写？？？？
            ArrayList myList = --------?????
  
  
  
  return series;
}

Answer 1

public static <T extends BaseBlob> List<T> Parse(byte[] data)
你后面那个要求很奇怪，泛型只是将类型参数化，但是你的实参并未给出与此类型相关的实例。
所以我不明白你究竟想怎么取。
如果如你所写：
List <T> series = new ArrayList <T>(); 
那么series中的每个instance应该都可以取得attrList。
但是如何填充这个List呢？

Answer 2

C# 代码的原意是 传入一个字节流（就是函数形参变量 byte[] data) 然后依据另一个泛型参数T 指时是要按个类反序列化,在函数里头首先取到这个T所代表的具体类的一成员变量信息，然后做类的反序列化操作，所以这个T 就没放到函数形参里，仅是放到函数返回值的类型里面C#代码是这样的：      public static List<T> Parse<T>(byte[] data) where T : BaseBlob, new()
        {
            return Parse<T>(data, GetDataTypeAttribute(typeof(T)));
        }其中GetDataTypeAttribute(typeof(T))这个函数就是取得该T所代表类的一些属性值我的问题就在于java里面怎么取得这个T所代表类的一些信息（比如这个类有一成员变量，成员函数啥的）

Answer 3

T t = series.get(0);

Answer 4

series是不存在的，正是函数里面要做的工作，把一个字节流，序列化成一个个的T所所表的类的实例对象

Answer 5

public static <T extends BaseBlob> List Parse(byte[] data)
throws IOException, ClassNotFoundException {
ObjectInputStream ois = new ObjectInputStream(
new ByteArrayInputStream(data));
T series = (T)ois.readObject();
return series.getAttrList();
}

Answer 6

bayougeng 感谢你的回复，
我需要先取得T 所代表具体一个类的成员变量呢？怎么做？

Answer 7

我知道你的意思是用java类库提供的功能直接序列化与反序列化，但我的问题是，我定义的那些子类对象含有不同的成员变量个数（类型各不相同，甚至是另一个类的对象），所以想按成员变量一个个的来反序列化，因为在之前的数据库中已有用C++版本 和C#版本类库写入了数据库，直接用你说的这种方法，不知道转化出来的这个对象会不会有问题

Answer 8

强制转换 if（xx instanceof T）
         T t = （T）xx；就可以用咯

Answer 9

如果attrList是public的，直接.attrList就行了。
我那种写法，是假设你定义了getter方法。

Answer 10

你可以使用反射的技术转型出一个具体类在通过java bean规范来获得你想要的参数亦成员变量

Answer 11

--------------------------
直接T.attrList?
问题是我要访问的这个attrList是该类的静态成员，就是要在这个类的对象反序列化之前就要取得，至于取哪个类就是参数T指定的，

Answer 12

 public static <T extends BaseBlob> List<T> Parse(byte[] data) throws IOException, ClassNotFoundException {
}
这样的java 泛型方法，怎么调用啊，
调用时，这个T的参数怎么传进来

Answer 13

如果只是为了取一个静态变量，那你要泛型干什么？
直接ClassName.attrList不就行了么。

Answer 14

但是我要这个函数可以返回具体的任何一子类的对象的List，难道不需要用泛型，有别的好办法？

Answer 15

public static <T extends BaseBlob> List <T> Parse(byte[] data) throws IOException, ClassNotFoundException {
} 
这样就应该可以了。
<T extends BaseBlob>这是一个类型参数推断，在实际应该中，就是根据赋值语句左边的类型来推断返回值的类型。但是即使你传入了类型参数，你根据data生成你要的Object，这个Object的attrList应该有确定的类型参数，你仍然要进行强制的类型转换才能得到合格的返回值。而这个类型转换有可能是不安全的。

Answer 16

public static <T extends BaseBlob> List <T> Parse(byte[] data) throws IOException, ClassNotFoundException 
{这里面怎么写？ T.attrList 直接取得这个参数值？
 
} 调用的时候这么写?
BaseBlob<subClass>.Parse(data)?  这样编译老是报错，

Answer 17

---------------------------
原意是这样：
定义了许多类 有一基类 Baseblob 还有许多它的子类，各个子类含有的数据成员变量的个数和类型各不相同（类型既可以是简单类型也可以复杂类型（另一个类的对象））
这些类就是对应着需求里面的数据结构，详细定义是与语言无关，之前已实现C#版本，和C++版本，并且已写入大量数据到文件系统，现在要做一个java版本的客户端类库
比如C#里是这样的：public static List<T> Parse<T>(byte[] data) where T : BaseBlob, new()
{
    return Parse<T>(data, GetDataTypeAttribute(typeof(T)));
}其中GetDataTypeAttribute(typeof(T))函数用来取得泛型参数T所代表的具体类的一些信息（属性等）调用者是这样的： List<CustomBlob> setsBlobList = Parse<CustomBlob>(bfData）;//bfData是byte[]型字节流
//CustomBlob 是基类的一子类
--------------------------------------------现在用java怎么实现上面类似功能的函数及怎么调用？

Answer 18

你在创建对象的时候不能传进来一个T的参数么? LZ可以看这个
http://www.javaeye.com/topic/585900?page=2 他这个方法比较那啥
import java.util.ArrayList;
import java.util.List;public class OkOk<T extends Object> {
List<T> list = new ArrayList<T>();
}这样是可以的 哇嘎嘎..

Answer 19

现在用java怎么实现上面类似功能的函数及怎么调用？ 
你能写一下sample code么

Answer 20

你前面的data[]是干嘛用的?GetDataTypeAttribute这个方法只返回类的属性么?

Answer 21

data[]是类的对象数组对应的字节流，后面的参数用来获取该类的一些信息，以便函数体内做序列化的操作

Answer 22

-----------------------------
是的，而且还要知道外部调用上，语法上怎么写？因为之前从没碰过JAVA，所以你可以给出简易示例代码么？

Answer 23

---------------------------------
java里面不可以实现？

Answer 24

楼主，我越来越不明白你想干什么了。
这样的问题实在很头疼，没办法把问题描述清楚。
你写清楚，传进来的这个泛型，你希望根据它和参数data得到什么，然后返回什么。

Answer 25

貌似在类里是获取不到这个信息的 我只说貌似啊 LZ别灰心 我现在尝试在这个类的对象方法里获取该类的类型信息 得到的不是 T 就是 ? 以前没这么想过 不过LZ既然能够创建某个泛型的对象 难道LZ还不知道泛型是什么么?

Answer 26

-------------------------------------
泛型的T就是可能为已定义的基类的所有子类之一，所以在函数里时，并不能确切知道T是什么，怎么用这个T实例化对象来？

Answer 27

 public static <T extends BaseBlob> List<T> Parse(byte[] data) throws IOException, ClassNotFoundException 
  {
  List<T> series = new ArrayList<T>();
  
  ArrayList attrList = T.attrList;
  
  for(int i=0;i<attrList.size();i++)
  {
  PrimeDataType dataType = (PrimeDataType)attrList.get(i);
  
  T blob = new T();//报错，本意是想实例化这个T所代表的类的实例，怎么改？？？
     
          switch (dataType)
          {
              case PrimeDataType.B:
                  blob.values[i] = reader.ReadByte();
                  break;
              case PrimeDataType.Bs:
                  blob.values[i] = (sbyte)(reader.ReadByte());
                  break;
              case PrimeDataType.C:
                  blob.values[i] = (char)reader.ReadByte();
                  break;
              case PrimeDataType.Cj:
                  blob.values[i] = (char)reader.ReadByte();
                  break;
               ...          }   }
    return series;

Answer 28

--------------------------
C#里可实例化，C++里也可以实例化，java里不行？

Answer 29

------------------------------------ public static <T extends BaseBlob> List<T> Parse(byte[] data) throws Exception 
  {       这里面怎么实例化 T 的对象？
         
}

Answer 30

首先很感谢各位java高手的回复，可能是我没有描述问清楚，至今没看到我想要的答案，就是问题好像没解决
这里再说一遍，期待java高手的指点，本人才用java两三天时间（之前用C#/C++多一点）最终外层这样调用：List<BlobDLLL> list = BaseBlob.<BlobDLLL>Parse(org_content);//org_content 是byte[]数组     
泛型函数： public static <T extends BaseBlob> List<T> Parse(byte[] data) throws Exception 
  {
  List<T> series = new ArrayList<T>();
          for(..) //些循环体内依据 字节流 的长度 和 T（某个继承BaseBlob 的类）对象本身长度 依次把字节流序列成一个个的对象，存入 series list里
          {
             T blob = new T() //？？？？这是报错的，但就是想实现 实例化这个泛型参数T 
             
             这样的功能C++ 和 C# 是可以实现实，难道java没办法实现？             ...
             
             series.add(blob);
          }
            return series;   
  }
  

Answer 31

class ParameterType<T>
{
    public void printT()
    {
          //通过反射获取T
          //写法应该是 获取参数化了的父类,如果没有参数化的父类那么返回当前类。
          //然后获取上面的泛型类型
    }
}
public class Main(String[] args)
{
     //如果你这样用是不能获取到T的运行时类型的,因为父类中的T在编译之后其实是一个Object了,当然  不能获取到真实的T的信息了。
      ParameterType<String> pt=new ParameterType<String>();     //但是如果你这样用就可以了
     //,因为子类编译之后保存了完整的继承信息，extends ParameterType<String>
    //既然类文件中记录了那些信息那么就可以通过反射给找出来
      ParameterType<String> subimpl=new SubClass();
}
class SubClass extends ParameterType<String>
{
}
//只是我的理解。我也看过编译之后的class文件的信息,那个T在编译之后是一个Object