「java泛型返回不同对象」java 泛型参数化类型获取实例对象

本篇文章给大家谈谈java泛型返回不同对象，以及java 泛型参数化类型获取实例对象对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、JAVA中怎么根据传入参数的不同返回不同类型的对象
• 2、java 根据参数返回不同的返回类型
• 3、Java一个方法返回两个不同的类型值怎么处理？
• 4、根据不同的参数list怎么返回不同的泛型结果
• 5、JAVA中的泛型用法一种： 返回值用法。
• 6、如何使用Java泛型映射不同的值类型

JAVA中怎么根据传入参数的不同返回不同类型的对象

for example:

Object create(String className) {

return Class.forName(className).newInstance();

}

java 根据参数返回不同的返回类型

如果要写成一个方法肯定是可以的。因为list 和set都是继承的collection，而且也都继承object类。

可以写成：

CollectionInteger fun(Collection Integer col){

return col;

}

Java一个方法返回两个不同的类型值怎么处理？

一个函数需要返回两个值的话 可以根据你自己的需求决定是用强类型还是弱类型

强类型的话 比较安全 但是写起来比较麻烦 代码也不是很美观

弱类型的话 代码比较优美一点 但是相对的 需要对类型判断好

// 强

class Data{

    ValueA a;

    ValueB b;

}

public Data function(){

    ...

    Data data = new Data();

    data.a = xxx;

    data.b = xxx;

    return data;

}

//弱

public Object[] function(){

    ValueA a;

    ValueB b;

    ...

    Object[] objs = new Object[]{a,b};

    return objs;

}

根据不同的参数list怎么返回不同的泛型结果

首先你得明白，Java里面泛型的用处，Java为了变量能在虚拟机（JVM）中合理分配并高效实用内存，才出了泛型这个东东。

你的意思应该是如果一个方法返回的是处理结果是ListString，那么获得了方法的值直接是ListString，不用强制转换就能实用；如果返回的是ListMap，那么同样获得返回值就是ListMap类型，也不用强转对吧？

如果是这样，你的想法就目前的JDK版本来说是实现不了的。

建议你还是返回Object类型，然后强转吧。

如果你使用Object作为返回值，你可以创建单独的数据类型检测方法做做强制类型转换。

不要偷懒哦:-)

JAVA中的泛型用法一种： 返回值用法。

1、对于泛型方法来说，是可以接收不同类型的参数，比如下图，使用泛型来操作List集合，然后向List中添加一条数据，看是否可以添加成功，创建泛型方法如图所示。

2、然后在写一个main方法来测试一下这个泛型方法，先向集合中添加一条String类型的数据，打印List集合中的元素，如图所示。

3、上面是往List集合中添加了一个String类型的数据，下图往List集合中添加一条Integer类型的数据并打印，当然也可以自己创建对象进行添加。

4、泛型也是可以限制要使用的参数类型的，比如上面，list集合中，只想加入数字类型的数据，当然也是可以的，只要让类中的T继承Number就行了，如图所示。

5、下面在测试一下，向集合中添加一个Long类型的数据并打印，如图所示。

6、最后输出就完成了。

如何使用Java泛型映射不同的值类型

使用Java泛型映射不同的值类型

考虑一个例子，你需要提供某种应用程序的上下文，它可以将特定的键绑定到任意类型的值。利用String作为键的HashMap，一个简单的、非类型安全（type safe）的实现可能是这样的：

public class Context {

private final MapString,Object values = new HashMap();

public void put( String key, Object value ) {

values.put( key, value );

}

public Object get( String key ) {

return values.get( key );

}

[...]

}

接下来的代码片段展示了怎样在程序中使用Context ：

Context context = new Context();

Runnable runnable = ...

context.put( "key", runnable );

// several computation cycles later...

Runnable value = ( Runnable )context.get( "key" );

可以看出，这种方法的缺点是在第6行需要进行向下转型（down cast）。如果替换键值对中值的类型，显然会抛出一个ClassCastException异常:

Context context = new Context();

Runnable runnable = ...

context.put( "key", runnable );

// several computation cycles later...

Executor executor = ...

context.put( "key", executor );

// even more computation cycles later...

Runnable value = ( Runnable )context.get( "key" ); // runtime problem

产生这种问题的原因是很难被跟踪到的，因为相关的实现步骤可能已经广泛分布在你的程序各个部分中。

为了改善这种情况，貌似将value和它的key、它的value都进行绑定是合理的。

在我看到的、按照这种方法的多种解决方案中，常见的错误或多或少归结于下面Context的变种：

public class Context {

private final String, Object values = new HashMap();

public T void put( String key, T value, ClassT valueType ) {

values.put( key, value );

}

public T T get( String key, ClassT valueType ) {

return ( T )values.get( key );

}

[...]

}

同样的基本用法可能是这样的：

Context context = new Context();

Runnable runnable = ...

context.put( "key", runnable, Runnable.class );

// several computation cycles later...

Runnable value = context.get( "key", Runnable.class );

乍一看，这段代码可能会给你更类型安全的错觉，因为其在第6行避免了向下转型（down cast）。但是运行下面的代码将使我们重返现实，因为我们仍将在第10行赋值语句处跌入ClassCastException 的怀抱：

Context context = new Context();

Runnable runnable = ...

context.put( "key", runnable, Runnable.class );

// several computation cycles later...

Executor executor = ...

context.put( "key", executor, Executor.class );

// even more computation cycles later...

Runnable value = context.get( "key", Runnable.class ); // runtime problem

哪里出问题了呢？

首先，Context#get中的向下转型是无效的，因为类型擦除会使用静态转型的Object来代替无界参数（unbonded parameters）。此外更重要的是，这个实现根本就没有用到由Context#put 提供的类型信息。这充其量是多此一举的美容罢了。

类型安全的异构容器

虽然上面Context 的变种不起作用，但却指明了方向。接下来的问题是：怎样合理地参数化这个key？ 为了回答这个问题，让我们先看看一个根据Bloch所描述的类型安全异构容器模式（typesafe heterogenous container pattern）的简装实现吧。

我们的想法是用key自身的class 类型作为key。因为Class 是参数化的类型，它可以确保我们使Context方法是类型安全的，而无需诉诸于一个未经检查的强制转换为T。这种形式的一个Class 对象称之为类型令牌（type token）。

public class Context {

private final MapClass?, Object values = new HashMap();

public T void put( ClassT key, T value ) {

values.put( key, value );

}

public T T get( ClassT key ) {

return key.cast( values.get( key ) );

}

[...]

}

请注意在Context#get 的实现中是如何用一个有效的动态变量替换向下转型的。客户端可以这样使用这个context：

Context context = new Context();

Runnable runnable ...

context.put( Runnable.class, runnable );

// several computation cycles later...

Executor executor = ...

context.put( Executor.class, executor );

// even more computation cycles later...

Runnable value = context.get( Runnable.class );

这次客户端的代码将可以正常工作，不再有类转换的问题，因为不可能通过一个不同的值类型来交换某个键值对。

有光明的地方就必然有阴影，有阴影的地方就必然有光明。不存在没有阴影的光明，也不存在没有光明的阴影。村上春树

Bloch指出这种模式有两个局限性。“首先，恶意的客户端可以通过以原生态形式（raw form）使用class对象轻松地破坏类型安全。”为了确保在运行时类型安全可以在Context#put中使用动态转换（dynamic cast）。

public T void put( ClassT key, T value ) {

values.put( key, key.cast( value ) );

}

第二个局限在于它不能用在不可具体化（non-reifiable ）的类型中（见《Effective Java》第25项）。换句话说，你可以保存Runnable 或Runnable[]，但是不能保存ListRunnable。

这是因为ListRunnable没有特定class对象，所有的参数化类型指的是相同的List.class 对象。因此，Bloch指出对于这种局限性没有满意的解决方案。

但是，假如你需要存储两个具有相同值类型的条目该怎么办呢？如果仅为了存入类型安全的容器，可以考虑创建新的类型扩展，但这显然不是最好的设计。使用定制的Key也许是更好的方案。

多条同类型容器条目

为了能够存储多条同类型容器条目，我们可以用自定义key改变Context 类。这种key必须提供我们类型安全所需的类型信息，以及区分不同的值对象（value objects）的标识。一个以String 实例为标识的、幼稚的key实现可能是这样的：

public class KeyT {

final String identifier;

final ClassT type;

public Key( String identifier, ClassT type ) {

this.identifier = identifier;

this.type = type;

}

}

我们再次使用参数化的Class作为类型信息的钩子，调整后的Context将使用参数化的Key而不是Class。

public class Context {

private final MapKey?, Object values = new HashMap();

public T void put( KeyT key, T value ) {

values.put( key, value );

}

public T T get( KeyT key ) {

return key.type.cast( values.get( key ) );

}

[...]

}

客户端将这样使用这个版本的Context：

Context context = new Context();

Runnable runnable1 = ...

KeyRunnable key1 = new Key( "id1", Runnable.class );

context.put( key1, runnable1 );

Runnable runnable2 = ...

KeyRunnable key2 = new Key( "id2", Runnable.class );

context.put( key2, runnable2 );

// several computation cycles later...

Runnable actual = context.get( key1 );

assertThat( actual ).isSameAs( runnable1 );

虽然这个代码片段可用，但仍有缺陷。在Context#get中，Key被用作查询参数。用相同的identifier和class初始化两个不同的Key的实例，一个用于put，另一个用于get，最后get操作将返回null 。这不是我们想要的……

//译者附代码片段

Context context = new Context();

Runnable runnable1 = ...

KeyRunnable key1 = new Key( "same-id", Runnable.class );

KeyRunnable key2 = new Key( "same-id", Runnable.class );

context.put( key1, runnable1 );//一个用于put

context.get(key2); //另一个用于get -- return null;

幸运的是，为Key设计合适的equals 和hashCode 可以轻松解决这个问题，进而使HashMap 查找按预期工作。最后，你可以为创建key提供一个工厂方法以简化其创建过程（与static import一起使用时有用）：

public static Key key( String identifier, Class type ) {

return new Key( identifier, type );

}

java泛型返回不同对象的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java 泛型参数化类型获取实例对象、java泛型返回不同对象的信息别忘了在本站进行查找喔。