Question

我想创建一个可以接受任何传入变量的函数，无论类型（reg_city <- function(){ if (if.is.empty(final_data)) { final_data %>% group_by(registrant_city) %>% summarise(Total= n()) %>% arrange(desc(Total)) %>% top_n(n=15)} }，int，double或其他对象如何），然后可能确定的类型在类型上有条件地变量和行为。

我该怎么做？

Answer 1

重载是最推荐的选项，大多数情况下您不需要接受任何类型变量的函数。

但是接受任何Object的函数呢？您可能需要使用instanceof并根据数据类型处理它们。

instanceof的使用：[Name of object instance] instanceof [Name of object type to match]

当且仅当对象实例的类型与要匹配的类型匹配时，

instanceof才返回boolean：true。

接受＆＃34;任何变量类型的函数或方法的一个示例：＆＃34;

public static void method(Object obj) {
    if (obj instanceof String)
        System.out.println("I am a String!");

    if (obj instanceof Integer)
        System.out.println("I am an Integer!");

    // Similarly for other types of Object
    if (obj instanceof ... )
        ...

    // The .getClass() is for any Object
    System.out.println(obj.getClass());
}

请注意，建议不要使用接受任何类型变量的函数。

Answer 2

根据您是否想要将盒装值与原子区分开来，您有以下选项，所有这些都在下面的测试中进行了演示：

使用Object：你将放弃原子类型，因为它们将被装箱
使用泛型：你将放弃原子类型，因为它们将被装箱

使用上述任何一种方法以及所有原子类型的重载

Class<?> anyObject(Object val) {
    return val != null ? val.getClass() : null;
}

<T> Class<?> anyGeneric(T val) {
    return val != null ? val.getClass() : null;
}

@Test
public void anyAsObject_alsoViaGenerics() {
    assertEquals(String.class, anyObject("a string"));
    assertEquals(String.class, anyGeneric("a string"));
    // atomic arrays are Ok
    assertEquals(boolean[].class, anyGeneric(new boolean[]{}));
    assertEquals(int[].class, anyGeneric(new int[]{}));
    // atomic: auto-boxed and thus not Ok
    assertEquals(Boolean.class, anyObject(true));
    assertEquals(Boolean.class, anyGeneric(true));
    assertEquals(Integer.class, anyObject(125));
    assertEquals(Integer.class, anyGeneric(125));
}

// with overloading

Class<?> any(Object val) {
    return val != null ? val.getClass() : null;
}

Class<?> any(boolean val) {
    return boolean.class;
}

Class<?> any(int val) {
    return int.class;
}

@Test
public void any_overloadedForAtomic() {
    assertEquals(String.class, any("a string"));
    assertEquals(Boolean.class, any(Boolean.TRUE));
    assertEquals(Integer.class, any(Integer.valueOf(125)));
    assertEquals(boolean[].class, any(new boolean[]{}));
    assertEquals(int[].class, any(new int[]{}));
    // atomic
    assertEquals(boolean.class, any(true));
    assertEquals(int.class, any(125));
}

Answer 3

你没有。你想要做的是重载你的功能并相应地实现每个案例。这是打字语言的美感和面向对象编程的美感。

Answer 4

最好和最简单的方法是使用过载技术...... 多次写你的方法，每次都有不同的签名...... 看看这个：

public void myFunc(int i)
{
System.out.println(i);
}
public void myFunc(double d)
{
System.out.println(d);
}
public void myFunc(String s)
{
System.out.println(s);
}
public void myFunc(boolean b)
{
System.out.println(b);
}

Answer 5

只需传递类型为Object的函数？

如何创建一个接受任何类型变量的函数？

5 个答案: