数组中协方差的正确使用

Question

基类有一个数据成员，它是一个对象数组 A[] 和一个访问器方法。我希望能够重写访问器以返回 B[]，其中 B 是 A 的子类。

在 Java 5.0 中，它允许我这样做，因为数组是协变的，但我得到了 当我尝试执行以下操作时出现 ClassCastException：

class Business {
    A[] clients;
    A[] getClientList() { return clients; } 
}  

class DoctorBusiness extends Business {
   B[] getClientList(){
      return super.clients; 
     //this line thwoes a classcastexception
  } 
 }

其中 Client 对应于 A，Patient 对应于 B，Patient 扩展 Client。
我该如何解决这个问题？我知道数组中的所有对象都将是 B 类型，并且希望避免每次访问客户端的数组元素时都必须向下转换为 Patient

Answer 1

刚刚怎么样

class A{}
class B extends A{}

public class Test<T extends A> {
    T[] t;

    public T[] get()
    {
        return t;
    }

    public static void main(String args[])
    {
        Test<B> t2 = new Test<B>();
        B[] b = t2.get();
    }
}

Answer 2

不可能的。

您可以使用 List，将其转换为 List，或者使用通用的 List。性能应该非常接近阵列。

Answer 3

请参阅我在您的问题中发表的评论。但如果我对你的问题的理解是正确的，那么以下情况适用：

A 不是 B 的子类型。这就是你得到异常的原因。根据您想要做的事情，这是行不通的。

我想到了一个解决方案，可以满足您的需求。进入界面的美丽概念！ =D

public interface ICommon 
{}

public class B extends A 
{
    protected B[] b;

    public ICommon[] Get()
    {
        return b;
    }

    public ICommon[] GetAncestor()
    {
        return a;
    }
}

public class A implements ICommon  
{
    protected A[] a;

    public ICommon[] Get()
    {
    return a;
    }
}

现在，因为他们共享一个公共接口。这将按您的意愿工作。

您需要公开允许您按该类型使用它们的方法，或者在使用它们时必须诉诸强制转换。这就是缺点

Answer 4

如果您可以更改超类，您可能希望按照 Steve B. 的建议使用泛型对其进行改造，或者至少使数组创建可由子类覆盖：

class Super {
    private A[] as;

    protected A[] newDataArray(int length) {
        return new A[length];
    }

    public A[] get() {
        return as;
    }
}

class Sub {
    @Override protected B[] newDataArray(int length) {
        return new B[length];
    }

    @Override public B[] get() {
        return (B[]) super.get(); // we know it's a B[] because we created it
    }
}

如果您无法更改超类，则只能这样做

class Sub extends Super {
    @Override public B[] get() {
        A[] as = super.get();
        return Arrays.copyOf(as, as.length, B[].class);
    }
}

：如果 as 包含无法分配给 B 的内容，>copyOf 将失败并出现 ArrayStoreException。

Answer 5

协变对于 Java 中的数组和泛型来说并不适用，因为它破坏了静态类型安全性。解决这个设计问题的唯一方法是在 Business 和 DoctorBusiness 类中使用单独的列表。

查看此维基百科页面中的“C# 和 Java 中的数组”部分，了解协方差

Answer 6

在登机时，您可以升级/降级您的类，但在 Java 或任何常见的面向对象语言中，您不能将水果降级为被视为苹果，即使您可以升级苹果的视图为被视为水果。

水果是苹果和橙子的超类。

Fruit f;
Apple, Orange extend Fruit;
Apple a;
Orange b;

根据常识，如果将 f 分配给 apple，

f = apple;

则不能将 f 返回为 Orange；

然而，
如果您分配了 a：

a = apple;

您将能够返回 Fruit

Fruit get(){
 return a;
}

您可以将苹果作为 Fruit 返回，但不能将 Fruit 作为苹果返回，因为如果 f 已经被分配为橙子怎么办？

然而，您可能会说，“B 扩展了 A 是一对一的关系，所以我不应该担心 A 的实例被分配给除 B 之外的任何其他类。”面向对象语言编译器并不是这么看的。 OO 编译器没有关系模型来使其能够检查和限制类扩展为一对一。

因此，回到OO原则的问题。 OO编程是一种态度。当你的态度正确时，你就不会遇到这样的困境，因为你根本不会考虑它。

请原谅我这么说，您遇到这个问题表明您可能是一个 Visual Basic（或 php 或 perl 程序员），试图将线性编程态度（与所有 vb 程序员一样）融入到 C# 或 Java 的维度中。当c#/java程序员和vb程序员相遇时，确实令人沮丧。

作为一名面向对象的程序员，您对对象层次结构的可视化将自发地（一些语言上不太敏锐的人会使用“自动”这个词）决定您的编程风格。正如当你的购物车里实际上有橙子时，你对水果等级的看法甚至不会让你想到为苹果付钱。

因此，在下面的示例中，您可以将 A 的实例设置为 B 的实例，然后返回 A 的实例。
但是你不能将 A 的实例作为 B 的实例返回；

class A{}
class B extends A{}

public class Test {
    A[] a;
    B[] b;

    public A[] get()
    {
        return a;
    }

    public void set(A[] a){
        this.a = a;
    }


  // Illegal
    public B[] getB(){
      return a;
    }

    public static void main(String args[])
    {
        Test t2 = new Test();
        B[] b = new B[0];
        t2.set(b);
        A[] a = t2.get();
    }
}

如果你确实坚持从 A 实例返回 B，那么你的 OO 概念和你的世界观都被打破了。

因此，考克斯先生的建议是正确的。您必须使用接口作为合约声明。您必须理解并自发地设计您正在编写的程序以及应用程序中的合同流程。就像当您购买杂货时，您会自发地与超市签订水果、蔬菜、调味品等合同。

您需要停止尝试从其超类实例 A 获取实例 B，并重新设计您的态度和心理过程，以自发地设计您需要接口的应用程序。

interface Edible{};
class Fruit implements Edible{...}
class Apple extends Fruit {...}

Interface FoodAisle{
  Edible get();
  void set(Edible e)throws WrongFoodException;
}

class FruitSection implements FoodAisle{
  Edible e;
  public Edible get(){
  }
}    

class AppleBucket extends FruitSection{
  Apple a;
  public Apple get(){
    return a;
  }

  public set(Edible e)
  throws WrongFoodException{
    if (!(e instanceof Apple)) throw WrongFoodException
    e = e;
  }
}

在设计跨食物扩展世界观时，你需要想象自己能够提出这样的问题：“如果他们在水果区的苹果桶里放一串橙子怎么办？”你的世界观会自发地跳起来大喊“我要破例向经理投诉，因为我把橙子误传成苹果来卖”。同样，无论你在做什么，如果你坚持尝试从 A 实例中获取 B，则意味着你需要了解你正在编程的业务和流程，就像经理需要了解食物一样层次结构。

程序员和数据模式设计者必须具备他们正在编程的流程和业务的专业知识。

您也可以屈服于 Steve B 的对类进行泛型化的建议。如果您选择使用泛型，则意味着

• 一旦您实例化了一条针对苹果的过道，您就无法尝试从该过道获取橙子。
• 您使用泛型是因为您希望在水果桶之间共享例程，但您并不是在尝试将橙子变成苹果的不可能的奇迹。

。

class FruitSection<E extends Edible>{
  E[] e;
  public Edible get(){
  }

  void set(E e){
  }
}


FruitSection<Fruit> fsect = new FruitSection<Fruit>();
Fruit[] ff = { .....};
fsect.set(ff);

AppleBucket<Apple> abuck = new FruitSection<Apple>();
Apple[] aa = { /* commalist of apples */};
abuck.set(aa);

将苹果放入水果区即可。

fsect.set(aa);

但是将任何旧水果放入苹果桶中是不可接受的：

abuck.set(ff);

像往常一样，我打字太快可能会产生一些打字错误和错位。如果是这样，请原谅我。