精华内容
下载资源
问答
  • 我想在这里实现的是由子类决定是否要将java.lang.String或java.util.HashMap作为参数传递给query()方法.接口只需要声明子类必须实现查询方法,但我不关心什么类型的参数子类想要传入.我有一个界面,如:interface A{...

    我想在这里实现的是由子类决定是否要将

    java.lang.String或java.util.HashMap作为参数传递给query()方法.接口只需要声明子类必须实现查询方法,但我不关心什么类型的参数子类想要传入.

    我有一个界面,如:

    interface A{

    public void query(T type);

    }

    两个子类如:

    public class B implements A {

    public void query(String type);

    }

    public class C implements A {

    public void query(HashMap type);

    }

    然后我有一个工厂类来生产B或C:

    public class AFactory {

    public static A> getType(String type) {

    if(type.equals("B")){

    return new B();

    } else if(type.equals("C")) {

    return new C();

    }

    }

    }

    这个想法是客户端可以使用如下的接口,而不依赖于B,C,如:

    A instance = AFactory.getType("B");

    String a = "test";

    instance.query(a);

    我在这里遇到的问题是:eclipse在instance.query(a)行上给出了错误:

    类型A中的方法查询(捕获#2-of?)不适用于参数(String).

    我认为问题是接口契约不知道查询应该期待String或HashMap.我只能想到解决这个问题的方法是,我必须将结果转换为:

    B instance = (B)AFactory.getType("B");

    String a = "test";

    instance.query(a);

    但是通过这样做,我将依赖于B而不仅仅是A(接口),这是我想在开始时避免的.知道如何在不依赖子类的情况下做到这一点(在本例中为B和C).

    展开全文
  • Java泛型方法类型参数

    2021-02-12 10:50:42
    我对泛型方法的显式类型参数有问题.我知道我可以这样做:Foo.function();假设有一个void function() {...}在Foo类中的函数.确切的问题是:>我想下载一些内容(Android版附Ion)>这些内容类似(文章,BlogArticle,...

    我对泛型方法的显式类型参数有问题.我知道我可以这样做:

    Foo.function();

    假设有一个

    void function() {...}

    在Foo类中的函数.确切的问题是:

    >我想下载一些内容(Android版附Ion)

    >这些内容类似(文章,BlogArticle,…),都实现了ContentItem接口

    >目前下载如下:

    例如新闻

    private void downloadNews() {

    Ion.with(this)

    .load(URL_NEWS)

    .as(new TypeToken>(){})

    .setCallback(new FutureCallback>() {

    @Override

    public void onCompleted(Exception e, List result) {

    // do something with result

    }

    });

    }

    如果我想下载博客文章,我必须更改网址和文章类(对于BlogArticle).

    我试图制作这样的通用函数:

    private void download(String url) {

    Ion.with(this)

    .load(url)

    .as(new TypeToken>(){})

    .setCallback(new FutureCallback>() {

    @Override

    public void onCompleted(Exception e, List result) {

    展开全文
  • 一般获取泛型这个需求很少用到,我也是在RPC远程调用接口过程中返回json数据,然后我要将json转换为对应的对象遇到。不过在复制实体类或者序列化成对象的时候很好用。如使用fastjson的api JSONArray.parseArray...

    一般获取泛型这个需求很少用到,我也是在RPC远程调用接口过程中返回json数据,然后我要将json转换为对应的对象遇到。不过在复制实体类或者序列化成对象的时候很好用。如使用fastjson的api JSONArray.parseArray(String text, Class clazz) 这种必须要拿到对应泛型才好转换成对应的数据。

    获取返回值泛型-比如我现在有个方法findAll

    public static ListfindAll(int id, Mapparams) {

    return null;

    }

    //通过反射获取到方法

    Method declaredMethod = RpcCglibClientProxy.class.getDeclaredMethod("findAll", int.class, Map.class);

    //获取返回值的类型

    Type genericReturnType = declaredMethod.getGenericReturnType();

    //System.out.println(genericReturnType);

    //获取返回值的泛型参数

    if (genericReturnType instanceof ParameterizedType) {

    Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();

    for (Type type : actualTypeArguments) {

    System.out.println("type " + type);

    }

    }

    3702916a72b7f7e94d8e86407d075eec.png

    获取方法参数的泛型

    //获取参数泛型

    //通过反射获取到方法

    Method declaredMethod = RpcCglibClientProxy.class.getDeclaredMethod("findAll", int.class,Map.class);

    //获取到方法的参数列表

    Type[] parameterTypes = declaredMethod.getGenericParameterTypes();

    for (Type type : parameterTypes) {

    System.out.println(type);

    //只有带泛型的参数才是这种Type,所以得判断一下

    if(type instanceof ParameterizedType){

    ParameterizedType parameterizedType = (ParameterizedType) type;

    //获取参数的类型

    System.out.println(parameterizedType.getRawType());

    //获取参数的泛型列表

    Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();

    for (Type typeAc: actualTypeArguments) {

    System.out.println(typeAc);

    }

    }

    }

    86ff9d9313cc6b66771f8078b1ccde9b.png

    展开全文
  • /**** @Description: 定义泛型类,在类名后添加 对尖括号* 并在尖括号中填写类型参数参数可以有多个,多个参数使用逗号分隔* T表示的是任意类型 type* E表示的是元素的类型 element* K表示的是key/value中的key* V...

    第一:参数类型用于类上案例:

    编写泛型类GenericClass:

    package com.test.cgb;

    /**

    *

    * @Description: 定义泛型类,在类名后添加 对尖括号

    * 并在尖括号中填写类型参数,参数可以有多个,多个参数使用逗号分隔

    * T表示的是任意类型 type

    * E表示的是元素的类型 element

    * K表示的是key/value中的key

    * V表示的是key/value中的value

    * 通常类型参数我们都是使用大写。

    * @author: caigb

    * @createTime: 2020年2月29日

    * @version:

    */

    public class GenericClass {

    public T value;

    public T getValue() {

    return value;

    }

    public void setValue(T value) {

    this.value = value;

    }

    }

    编写测试类:

    public class GenericDemo {

    public static void main(String[] args) {

    // 参数类型为String

    GenericClass genericClassOfString = new GenericClass<>();

    genericClassOfString.setValue("用于类上的泛型");

    String str = genericClassOfString.getValue();

    System.out.println("str = " + str);

    // 参数类型为Integer

    GenericClass genericClassOfInteger = new GenericClass<>();

    genericClassOfInteger.setValue(111);

    Integer intNum = genericClassOfInteger.getValue();

    System.out.println("intNum = " + intNum);

    }

    输出结果为:

    str = 用于类上的泛型

    intNum = 111

    ==================================================================================================================================

    第二个:泛型接口:

    定义接口如:

    /**

    *

    * @Description: 用于接口上的泛型

    * @author: caigb28355

    * @createTime: 2020年2月29日

    * @version:

    */

    public interface GenericInterface {

    void show(T value);

    }

    那么针对这个接口我们可以分别定义多种类型的实现类如:

    IntegerShowGenericInterfaceImpl:

    package com.test.cgb;

    // 泛型类型参数为Integer

    public class IntegerShowGenericInterfaceImpl implements GenericInterface{

    @Override

    public void show(Integer value) {

    System.out.println(" 整数型 "+ value);

    }

    }

    StringShowGenericInterfaceImpl:

    package com.test.cgb;

    // 泛型类型参数为String

    public class StringShowGenericInterfaceImpl implements GenericInterface{

    @Override

    public void show(String value) {

    System.out.println(" 字符串 "+ value);

    }

    }

    编写测试类如下:

    public class GenericDemo {

    public static void main(String[] args) {

    GenericInterface IntFace = new IntegerShowGenericInterfaceImpl(); // 向上转型

    IntFace.show(200);

    GenericInterface StringFace = new StringShowGenericInterfaceImpl(); // 向上转型

    StringFace.show("字符串");

    }

    // 输出结果为:

    整数型 200

    字符串 字符串

    ==================================================================================================================================

    第三:泛型方法,可以定义在泛型类中,也可以定义在普通类中。如果可以定义泛型方法,那就尽量定义泛型方法

    泛型方法类定义如:

    package com.test.cgb;

    /**

    *

    * @Description: 泛型方法,可以定义在泛型类中,也可以定义在普通类中

    * 定义泛型方法,在返回值前边,修饰符后边添加尖括号,并在其中填写类型参数

    * 如果可以定义泛型方法,那就尽量定义泛型方法

    * @author: caigb

    * @createTime: 2020年2月29日

    * @version:

    */

    public class GenericFun {

    public static void saveScore(T score) {

    // 这是一个保存分数的方法,分数的类型可以是int,double,float...数值类型

    // 我们对分数进行复杂操作......

    System.out.println("score = " + score);

    }

    }

    编写测试类如下:

    public class GenericDemo {

    public static void main(String[] args) {

    GenericFun.saveScore(20.0);

    GenericFun.saveScore(20);

    }

    打印结果如下:

    score = 20.0

    score = 20

    但是上面这个例子有个不足的就是,命名这个方法是用来保存分数的,由于使用了static形式,所以可以接收所有类型的值比如字符串中文,那么就有点违背最初的想法了,如:

    public static void main(String[] args) {

    GenericFun.saveScore(20.0);

    GenericFun.saveScore(20);

    GenericFun.saveScore("保存分数的入参竟然是中文");

    }

    打印结果有:

    score = 20.0

    score = 20

    score = 保存分数的入参竟然是中文

    所以为了改进上面的缺陷,我们需要限制一下参数类型,于是要对引入类型参数做一下限定,这个限定可以是类,也可以是接口,而且可以同时限定多个,如果有多个,可以使用&符号连接,如果限定中既有类又有接口,那么类一定要写在前面或者如:

    public class GenericFun {

    // T extends Number表示T这个类型必须继承自Number类型,也就是一定要是Number类的字类,那么也就不能是String类型了

    public static void saveScore(T score) {

    // 这是一个保存分数的方法,分数的类型可以是int,double,float...数值类型

    // 我们对分数进行复杂操作......

    System.out.println("score = " + score);

    }

    // Double 和Float都是继承字Number类如:

    //public final class Double extends Number implements Comparable {

    // /**

    // * A constant holding the positive infinity of type

    // * {@code double}. It is equal to the value returned by

    // * {@code Double.longBitsToDouble(0x7ff0000000000000L)}.

    // */

    // public static final double POSITIVE_INFINITY = 1.0 / 0.0;

    //}

    //public final class Float extends Number implements Comparable {

    // /**

    // * A constant holding the positive infinity of type

    // * {@code float}. It is equal to the value returned by

    // * {@code Float.intBitsToFloat(0x7f800000)}.

    // */

    // public static final float POSITIVE_INFINITY = 1.0f / 0.0f;

    }

    这样改造之后,在测试类中如果还是调用GenericFun.saveScore("保存分数的入参竟然是中文")方法的话就会报错如:

    public class GenericDemo {

    public static void main(String[] args) {

    GenericFun.saveScore(20.0);

    GenericFun.saveScore(20);

    // 下面这句报错信息就是The method saveScore(T) in the type GenericFun is not applicable for the arguments (String)

    GenericFun.saveScore("这里有中文");

    }

    ===============================================================================================================================

    泛型之类型擦出重要知识点扩展:下面让我们一起学习下泛型是如何擦出的,我们要知道,对于JVM来说,根本没有泛型这个概念,只有具体类型也就是说在运行期间根本就没有GenericClass,有的只是普通类和方法。JVM都会自动提供了一个相应的原始类型替换。在编译期间必要时会插入强制类型转换方法。

    JVM在泛型编译时,做两件事:

    1.去掉类名后的尖括号和尖括号的类型参数,剩下的名字就是对应的类名

    2.对于类中使用了类型参数的变量的类型,如果没有限制类型的情况下,使用Object替换,如果有类型限定,使用限定的类型替换。下面我们一起看看:

    首先我们在工作空间找到对应的class字节码文件路径,然后在该路径打开命令符窗口:

    5893e2333b6f948a203f7c0db7114dac.png

    最初我们的源文件GenericClass.java代码如:

    public class GenericClass {

    public T value;

    public T getValue() {

    return value;

    }

    public void setValue(T value) {

    this.value = value;

    }

    }

    第二步我们可以在cmd.exe窗口输入命令javap -help可以看到各种命令:

    d2e235d0778c01db3936d47ad3965171.png

    第三步我们可以输入输入命令javap -c -s GenericClass.class,我们可以看到Object类

    98914c76543d1005c3c3675f5ede42ca.png

    那么如果源代码是这样的呢?就是有类型限定的如:

    public class GenericClass {

    public T value;

    public T getValue() {

    return value;

    }

    public void setValue(T value) {

    this.value = value;

    }

    }

    那么就替换成Number了:

    a575b872e0322e1c5c4a7c19f08e4ff2.png

    展开全文
  • Java综合:泛型方法及动态参数

    千次阅读 2021-01-16 01:58:18
    所以我们也可以采用以下的方法进行调用:Lists ints = Lists.toList(new Integer[]{1,2,3});不过在使用vararg功能时,需要留意的是,当方法中待传入的参数除了动态参数外,还有...(3) 调用泛型方法时显式给定类型参...
  • Java泛型接口

    千次阅读 2021-02-27 08:08:03
    一:泛型接口先给大家普及一个概念(在后面的也会有),其实在以后的开发中我们开发一个项目最基本的目的是将数据库中的数据显示到客户端或者客户端可以将数据录入数据库实现数据的交互,那么数据库分为关系型数据库...
  • 今天碰到了这么一个问题,我用HttpClient访问第三方接口的时候出现了第三方接口返回值不统一的情况。举例说明:当访问A接口的时候,返回值用JSONObject.parseObject("返回的String") 解析没问题。但是当B接口的时候...
  • 我一直在阅读有关泛型方法的文章,以为我理解了泛型类型参数如何约束方法参数类型,但是当我用实际代码测试了一些想法时,我得到了意外的结果.这是我不理解的简单通用方法:private static void foo(T[] t1, T[] t2){t2...
  • import java.lang.reflect.GenericDeclaration; import java.lang.reflect.Method; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import java.lang.reflect.TypeVariable; import ...
  • I have an interface like this:public interface DataObject {...public void copyFrom(DataObject source);...}And a class that implements it:public class DataObjectImpl implements DataObject {...@Override...
  • 泛型机制:将数据类型的明确工作推迟到,创建对象或者调用方法时才去明确的机制泛型好处(1):把运行时期的问题提前到了编译期间(2):避免了向下转型(3):优化了程序设计,解决了黄色警告线注意:泛型...
  • Java中,是否可以定义一个接口,该接口具有接收实现类参数方法接口:public interface MyInterface {public void method(T object);}类:public class A implements MyInterface {public void method(A object) ...
  • 我要特别指出泛型方法(您的问题所涉及的问题),我还要进一步指出,类型推断理论上将导致这种界限毫无意义。 如果我们重新检查以上假设签名中声明的类型参数: 假设呼叫者未明确指定MyClass.foo("asdf", 42)和...
  • 代码在下面 ,保留起来,慢慢看: 1、最基本的泛型接口 import java.util.List;import java.util.Map;import javax.servlet.http.HttpSession;/** * 基本的泛型接业务管理端增删改查的东西写得多了,懒得重复那么多...
  • Java可变参数列表,泛型方法,以及泛型中的extends,super,?等规则可变参数列表在Think In Java $5.8.1(P102)节讲到是Java SE5引进的新特性,正如上面的那篇文章所提到:a,当调用方法时,方法的参数的类型或个数...
  • lambda表达式无法指定类型参数,因此它不是泛型的。但是,与lambda表达式相关联的函数接口泛型的。在这种情况下,lambda表达式的目标类型由声明函数接口引用时指定的参数类型确定。语法interfaceSomeFunc{Tfunc(Tt...
  • 泛型接口:定义一个泛型接口:通过类去实现这个泛型接口的时候指定...泛型方法:引用其他人写的,觉得不错:定义泛型方法时,必须在返回值前边加一个,来声明这是一个泛型方法,持有一个泛型T,然后才可以用泛型T...
  • java获取泛型信息

    2021-02-25 20:20:22
    总结一下java中获取与泛型相关的信息的知识,不如说是使用方法.网上也有很多类似的优秀文章,这里主要做一个知识的总结.通过反射获取泛型信息的常见例子://beanpackage testProject;public class Person {private ...
  • 其中JDK1.5中泛型是一件非常重要的实现技术,它可以帮助我们解决程序的参数转换问题。本文为大家详细介绍一下泛型。一、泛型问题的引出假设需要你定义一个描述坐标的程序类Point,需要提供两个属性x、y。对于这两个...
  • 初步情况:我为其他一些通用接口A< T>创建了一个工厂接口:public interface Factory> {public X create();}问题描述:现在我遇到的问题是我需要为每个类型T实例化一个工厂.这变得非常不方便,特别是如果...
  • java定义泛型方法本文将详细介绍java泛型的用法以及泛型的原理java泛型泛型是在J2 SE1.5中引入的一个特性 可以将类型抽象为一个参数 从而简化代码和实现类型安全如何使用泛型泛型可以用于方法 类和接口通过尖括号加...
  • 您可以编写一个可以用不同类型的参数调用的泛型方法声明。根据传递给泛型方法参数类型,编译器会适当地处理每个方法调用。以下是定义泛型方法的规则-所有泛型方法声明都有一个类型参数部分,该类型参数部分由方...
  • 泛型方法 问题引入 如果我们需要产生多个对象,每个对象的逻辑完全一样,只是对象内的成员变量的类型不同。那我们如何去做? 我们新建一个工程 做一个构造方法public Cls1(int a){ this.a =a; ...
  • 这种参数类型可以用在类、接口和方法的创建中,分别称为泛型类、泛型接口泛型方法Java语言引入泛型的好处是安全简单。在Java SE 1.5之前,没有泛型的情况的下,通过对类型Object的引用来实现参数的“任意化”,...
  • Java 泛型

    2021-03-17 16:01:19
    泛型概述泛型java中有很重要的地位,在面向对象编程及各种设计模式中有非常广泛的应用。什么是泛型?为什么要使用泛型?《Java 核心技术》中对泛型的定义是:“泛型” 意味着编写的代码可以被不同类型的对象所重用...
  • 获取java泛型参数类型

    2021-03-01 09:12:25
    1、Type和Class的区别简单来说,Class实现了Type接口。Type源码定义:packagejava.lang.reflect;/***TypeisthecommonsuperinterfaceforalltypesintheJava*programminglanguage.Theseincluderawtypes,...
  • 这种参数类型可以用在类、接口和方法的创建中, 分别称为泛型类、泛型接口泛型方法. Java语言引入泛型的好处是安全简单.今天就从以下几个方面介绍一下java的泛型: 基础, 泛型关键字, 泛型方法, 泛型类和接口.基础:...
  • 前言实际开发中,泛型使用到处可见。有时候定义接口时,经常使用泛型,而不是指定具体对象...本篇讲述如何获取类或接口泛型类型(参数化类型ParameterizedType)。实例1.定义泛型接口public interface Response{void...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 108,151
精华内容 43,260
关键字:

java接口方法参数泛型

java 订阅