Question

我知道以前曾有人问过这个问题，但是我不太理解/答案没有帮助我，因此，在我开始学习Java的过程中，我希望在此方面有所帮助。

我想创建一个对类的实例进行计数并向我返回数字的函数，例如我拥有：

Public class A{}
Public class A.a extends A{}
Public class A.b extends A{}

我有一个A []数组，该数组具有A，A.a和A.b的实例，我想计算该数组中A，A.a或A.b的实例，所以我创建了以下函数：

int countA.a(A[] array){
int counter = 0;
  for(int i = 0; i < array.length; i++){
    if(array[i] instanceof A.a){
      counter++;
    }
  }
  return counter;
}

int countA.b(A[] array){
int counter = 0;
  for(int i = 0; i < array.length; i++){
    if(array[i] instanceof A.b){
      counter++;
    }
  }
  return counter;
}

我的问题是，我该怎么做：

int countInstances(A[] array, class n){
int counter = 0;
  for(int i = 0; i < array.length; i++){
    if(array[i] instanceof n){
      counter++;
    }
  }
  return counter;
}

感谢您的耐心！

Answer 1

您可以使用Class类：

int countInstances(A[] array, Class<? extends A> n){

您应该在instanceof类中使用isInstance方法，而不是Class。

if(n.isInstance(array[i])){
  counter++;
}

用法：

int count = countInstances(someArray, SubclassOfA.class);

Answer 2

您可以使用Class或使用

从实例中获取类型的A.class

A myA = new A();
Class<?> clazzOfA = myA.getClass();

并将其作为类型Class<?>的参数传递

所以在您的示例中，类似：

int instances = countInstances(myArray, A.b.class);

int countInstances(A[] array, Class<?> n){
int counter = 0;
  for(int i = 0; i < array.length; i++){
    if(array[i].getClass() == n){
      counter++;
    }
  }
  return counter;
}

一些例子：

boolean hasSameClass(Object type, Class<?> n){
    return type.getClass() == n;
}

hasSameClass(new LinkedList(), ArrayList.class);    // false
hasSameClass(new ArrayList(), LinkedList.class);    // false
hasSameClass(new ArrayList(), ArrayList.class);     // true
hasSameClass(new ArrayList(), List.class);          // false

Answer 3

由于要获取两个子类的实例的计数，因此可以按以下步骤进行操作：

import java.util.HashMap;
import java.util.Map;

class A {
}

class AA extends A {
}

class AB extends A {
}

public class Main {
    public static void main(String[] args) {
        // Test
        A[] array = { new AA(), new AB(), new AA(), new AA(), new AB() };
        System.out.printf("There are %d instances of AA and %d instances of BB.", countInstances(array).get("AA"),
                countInstances(array).get("AB"));
    }

    static Map<String, Integer> countInstances(A[] array) {
        Map<String, Integer> map = new HashMap<String, Integer>();
        map.put("AA", 0);
        map.put("AB", 0);
        for (A instance : array) {
            if (instance instanceof AA) {
                map.put("AA", map.get("AA") + 1);
            } else if (instance instanceof AB) {
                map.put("AB", map.get("AB") + 1);
            }
        }
        return map;
    }
}

输出：

There are 3 instances of AA and 2 instances of BB.

如有任何疑问/问题，请随时发表评论。

如何将类作为函数参数传递

3 个答案: