4

我的意思是，例如在 C# 中，我可以编写一个像这样的通用方法：

public static void Concatenate<T> (T arg1, T arg2) 
{
    Console.WriteLine(arg1.ToString() + arg2.ToString());
}

然后如果我以这些不同的方式调用该方法：

Concatenate("one", "two"); // will work just fine, outputs "onetwo"
Concatenate(1, 2); // will also work great, outputs 12
Concatenate("one", 2) // will give a compiler error

或者，我可以像这样调用该方法：Concatenate<string>("one", "two");并确保只有字符串进入......

现在，如果我在 Java 中尝试完全相同的事情

public static <T> void concatenate(T arg1, T arg2) {
    System.out.println(arg1.toString() + arg2.toString());
}

并以与 c# 示例完全相同的方式调用该方法：

concatenate("one", "two"); // will work just fine, outputs "onetwo"
concatenate(1, 2); // will also work great, outputs 12
concatenate("one", 2) // will work fine and outputs "one2"

据我所知，我不能调用这样的方法，concatenate<String>("One", "Two");因为那样会给我一个错误

有什么方法可以添加我在 c# 中找到的那种类型安全性？

所以我不会冒险在任何一个地方输入任何类型并且只会收到警告......

一个更好的例子是使用可变参数

在 C# 中我会这样做：

public static void QuickSort<T>(params T[] args) // same as (T... args) in java
{
    // code
}

并且在调用它时，我可以确定只有一种参数可以通过例如执行以下操作：

QuickSort<int>(5, 9, 7, 3, 2, 5, 4, 1);

而在java中我可以做到这一点：

quickSort(5, "nine", 7, 3, "two", 5, 4, 1);

并且只从 IDE 得到警告，而它会在 c# 中给出错误

所以我的问题是，有什么方法可以像在 c# 中一样“锁定”java 中的参数类型，a-laQuickSort<int>(args)而不是quickSort(args)？

4

3 回答 3

4

据我所知，我不能调用这样的方法，concatenate<String>("One", "Two")因为那样会给我一个错误

实际上，你可以，只是语法有点不同：

public class Main {

    public static <T> void concatenate(T arg1, T arg2) {
        System.out.println(arg1.toString() + arg2.toString());
    }

    public static void main(String[] args) {
        Main.<String>concatenate("one", "two"); // will work just fine, outputs "onetwo"
        Main.<Integer>concatenate(1, 2); // will also work great, outputs 12
        Main.<String>concatenate("one", 2); // will fail at compile time
    }
}

如果concatenate()是非static方法，则语法为obj.<String>concatenate(...).

至于你的第二个例子：

public class Main {

    public static <T> void quickSort(T... args) {
    }

    public static void main(String[] args) {
        quickSort(5, "nine", 7, 3, "two", 5, 4, 1);                // warning
        Main.<Integer>quickSort(5, "nine", 7, 3, "two", 5, 4, 1);  // error
    }
}

在这里，Main.<Integer>quickSort(...)失败并出现以下错误：

Main 类型的参数化方法 quickSort(Integer...) 不适用于参数 (Integer, String, Integer, Integer, String, Integer, Integer, Integer)

于 2013-03-03T19:03:34.543 回答
2

您可以明确使用泛型参数，但语法与您尝试的不同：

对于实例方法：

instance.<String>concatenate("a","b")

对于静态方法：

MyClass.<String>concatenate("a","b")
于 2013-03-03T19:05:52.017 回答
1

你所问的没有“类型安全”。Concatenate("one", 2)是完全类型安全的。从类型安全的角度来看，没有理由禁止它。泛型不是为了做出任意限制。

于 2013-03-03T21:31:55.713 回答