2

例子

abstract class A
{
  protected static Queue<String> q = new ArrayList<String>();

  abstract void myAbstractMethod();

  public doConcreteThings()
  {
     //busy code utilizing a 'q'
     q.add("something");
     myAbstractMethod();
     //busy code
  }

}

class B extends A
{

  public void myAbstractMethdo()
  {
     //creates concrete implementation using 'q'
  }
}

class C extends A
{

  public void myAbstractMethdo()
  {
     //creates concrete implementation using 'q'
  }
}
  • 每个扩展类都会有自己的静态队列吗？
  • 如果没有，我如何确保在父类中定义静态变量的通用功能，但每个类都有自己的静态变量（因此是静态队列）
4

5 回答 5

3

不，所有班级将共享一个队列。一种方法是在每个子类中都有一个单独的静态队列，并添加另一个getQueue()返回此队列的受保护方法。这样每个子类都可以有自己的队列。

请注意，这getQueue()将是一个非静态方法，但返回一个静态变量引用。这使您可以在子类中实现它，而它的行为就像静态方法一样“有效”（它不需要访问this）。

abstract class A
{
  protected abstract Queue<String> getQueue();
  public abstract void myAbstractMethod();

  public doConcreteThings()
  {
     //busy code utilizing a 'q'
     getQueue().add("something");
     myAbstractMethod();
     //busy code
  }
}

class B extends A
{
  private static Queue<String> q = new ArrayList<String>();
  protected Queue<String> getQueue() { return q; }

  public void myAbstractMethod()
  {
     //creates concrete implementation using 'q'
  }
}

class C extends A
{
  private static Queue<String> q = new ArrayList<String>();
  protected Queue<String> getQueue() { return q; }

  public void myAbstractMethod()
  {
     //creates concrete implementation using 'q'
  }
}
于 2012-10-22T13:46:07.907 回答
2

每个扩展类都会有自己的静态队列吗？

  • 不，静态变量绑定到您定义它的特定类。如果您想为每个子类使用不同的静态变量，则需要显式定义它们。

如何确保在父类中定义静态变量的通用功能但每个类都有自己的静态变量

  • 这是不可能的，正如第一种情况所述的原因。不同的类不共享静态变量。同一类的不同实例共享它们。

但是，您可以使用名称访问类中static定义的变量。ParentChild classParent Class

解决方法： -

您可以getters & setters (non-static)在您queue的每一个中为您定义subclasses，也可以static queue为它们中的每一个定义不同的。现在，每次调用子类的方法时（通过多态性），它只会返回static queue该类中定义的方法。

于 2012-10-22T13:44:07.203 回答
0
  • 每个扩展类都会有自己的静态队列吗？不，他们可以访问 A 中的同一个队列 q。所以 B 和 C 都可以访问 q，但 q 的唯一实例在 A 中。
于 2012-10-22T14:05:40.373 回答
0

不，静态变量属于您定义它们的实体，即使它们是抽象类或接口。

我真的很想挑战你为什么想要你提出的设计，但如果你真的想让每个子类都有自己的（静态）队列，你可以这样做：

abstract class A
{
  abstract Queue getQueue();

  abstract void myAbstractMethod();

  public doConcreteThings()
  {
     //busy code utilizing a 'q'
     getQueue().add("something");
     myAbstractMethod();
     //busy code
  }    
}

class B extends A
{
protected static Queue<String> q = new ArrayList<String>();

  public void myAbstractMethdo()
  {
     //creates concrete implementation using 'q'
  }
  public Queue getQueue() {
    return queue;
  } 
}

class C extends A
{
protected static Queue<String> q = new LinkedListList<String>();

  public void myAbstractMethdo()
  {
     //creates concrete implementation using 'q'
  }

public Queue getQueue() {
    return queue;
 } 
}
于 2012-10-22T13:45:11.383 回答
0

在继承方面，静态变量与对象变量不同。例如：您有一个带有静态变量和对象变量的超类。当您扩展该类时，您可以覆盖对象变量，它对于该类是唯一的，但是对于静态变量来说这是不同的。静态变量在所有扩展超类的类中都是相同的。

于 2012-10-22T13:47:51.117 回答