Java 正在传递ExecContext<&燃气轮机；当您不'；I don’我不知道那是什么类型

当我不知道泛型类型时，如何将泛型类型传递给方法

public static class ExecContext<E> {

    public void doSomething(E e) {

        System.out.println(e);
    }
}

public static void exec(ExecContext<?> ctx) {

    String s = new String("saoj");

    ctx.doSomething(s); // <============== COMPILE ERROR
}

公共静态类ExecContext{
公共无效剂量（E）{
系统输出打印ln（e）；
}
}
公共静态void exec（ExecContext ctx）{
字符串s=新字符串（“saoj”）；
ctx.doSomething；//
publicstaticvoidexec（ExecContext-ctx）

我应该这样做

编辑：

这应该可以做到……不过，您的操作方式略有改变：

public class Main
{
    public static void main(String[] args)
    {
        final ExecContext<String>  stringCtx;
        final ExecContext<Integer> integerCtx;

        stringCtx  = new ExecContext<String>();
        integerCtx = new ExecContext<Integer>();
        exec(stringCtx, "Hello, World");
        exec(integerCtx, 42);
    }

    public static class ExecContext<T>
    {
        public void doSomething(final T e)
        {
            System.out.println(e);
        }
    }

    public static <T> void exec(final ExecContext<T> ctx,
                                final T              value)
    {
        ctx.doSomething(value);
    }
}

公共类主
{
公共静态void main（字符串[]args）
{
最终执行上下文stringCtx；
最终执行上下文integerCtx；
stringCtx=新的ExecContext（）；
integerCtx=newexeccontext（）；
执行官（stringCtx，“你好，世界”）；
执行主任（integerCtx，42）；
}
公共静态类ExecContext
{
公共无效剂量测定（最终测试）
{
系统输出打印ln（e）；
}
}
公共静态void exec（最终ExecContext ctx，
最终T值）
{
ctx.剂量测定法（数值）；
}
}
公共静态void exec（ExecContext ctx）

我应该这样做

编辑：

这应该可以做到……不过，您的操作方式略有改变：

public class Main
{
    public static void main(String[] args)
    {
        final ExecContext<String>  stringCtx;
        final ExecContext<Integer> integerCtx;

        stringCtx  = new ExecContext<String>();
        integerCtx = new ExecContext<Integer>();
        exec(stringCtx, "Hello, World");
        exec(integerCtx, 42);
    }

    public static class ExecContext<T>
    {
        public void doSomething(final T e)
        {
            System.out.println(e);
        }
    }

    public static <T> void exec(final ExecContext<T> ctx,
                                final T              value)
    {
        ctx.doSomething(value);
    }
}

公共类主
{
公共静态void main（字符串[]args）
{
最终执行上下文stringCtx；
最终执行上下文integerCtx；
stringCtx=新的ExecContext（）；
integerCtx=newexeccontext（）；
执行官（stringCtx，“你好，世界”）；
执行主任（integerCtx，42）；
}
公共静态类ExecContext
{
公共无效剂量测定（最终测试）
{
系统输出打印ln（e）；
}
}
公共静态void exec（最终ExecContext ctx，
最终T值）
{
ctx.剂量测定法（数值）；
}
}
尝试这样做是件坏事。如果您不知道泛型类型是什么，那么如何知道传递
字符串是否是类型安全的

如果您真的想这样做，您必须向
exec
方法添加适当的注释，告诉它抑制不安全/未检查的类型转换错误。但这只是在运行时将编译变成一个潜在的
ClassCastException
，可能会被
ExecContext的某些子类型意外抛出
在
doSomething
方法中执行不同操作

编辑我认为以下内容也不正确：

    public static <T> void exec(ExecContext<T> ctx) {
        String s = new String("saoj");
        ctx.doSomething(s);
    }

现在，当
exec
调用
doSomething
方法时，它将传递一个
String
实例作为参数，其中
doSomething
方法的通用签名表示它应该传递一个
E
的实例；即
整数
，这是一件不好的事情如何知道泛型类型是什么，如何知道传递
字符串是否是类型安全的

如果您真的想这样做，您必须向
exec
方法添加适当的注释，告诉它抑制不安全/未检查的类型转换错误。但这只是在运行时将编译变成一个潜在的
ClassCastException
，可能会被
ExecContext的某些子类型意外抛出
在
doSomething
方法中执行不同操作

编辑我认为以下内容也不正确：

    public static <T> void exec(ExecContext<T> ctx) {
        String s = new String("saoj");
        ctx.doSomething(s);
    }

现在，当
exec
调用
doSomething
方法时，它将传递一个
String
实例作为参数，其中
doSomething
方法的通用签名表示它应该传递一个
E
的实例；即
Integer
这将不起作用，因为您传递的是execontext（类型未知），因此您在编译时不知道ExecutionContext包含什么类型

您必须这样做：

public class Test {

     public static class ExecContext<E> {

         public void doSomething(E e) {

             System.out.println(e);
         }
     }

     public static void exec(ExecContext<Object> ctx) {

         String s = new String("saoj");

         ctx.doSomething(s); // <============== NO COMPILE ERROR
     }
  }

公共类测试{
公共静态类ExecContext{
公共无效剂量（E）{
系统输出打印ln（e）；
}
}
公共静态void exec（ExecContext ctx）{
字符串s=新字符串（“saoj”）；
ctx.doSomething；//这将不起作用，因为您正在传递ExecutionContext（类型未知），因此在编译时不知道ExecutionContext包含什么类型

您必须这样做：

public class Test {

     public static class ExecContext<E> {

         public void doSomething(E e) {

             System.out.println(e);
         }
     }

     public static void exec(ExecContext<Object> ctx) {

         String s = new String("saoj");

         ctx.doSomething(s); // <============== NO COMPILE ERROR
     }
  }

公共类测试{
公共静态类ExecContext{
公共无效剂量（E）{
系统输出打印ln（e）；
}
}
公共静态void exec（ExecContext ctx）{
字符串s=新字符串（“saoj”）；
ctx.剂量测定法（s）；//您可能需要向
exec
方法添加泛型，并将该泛型参数用作ExecContext的泛型参数。我从未在Java中创建泛型类/方法，因此我不确定语法，但这可能并不难。您可能需要向
exec
方法添加泛型，并使用该泛型参数作为ExecContext的泛型参数，我从未在Java中创建过泛型类/方法，因此我不确定语法，但这可能并不难。