Java中的抽象变量？

Question

我来自 c#，这很容易而且可能。

我有这个代码：

public abstract class clsAbstractTable {

    public abstract String TAG;
    public abstract void init();

}

但是 Eclipse 告诉我我使用了非法修饰符。

我有这门课：

public class clsContactGroups extends clsAbstractTable {


}

我想要以这种方式定义的变量和方法，让 Eclipse 提示我，我有未实现的抽象 变量 和方法。

如何定义我的抽象类，以便系统提示我实现抽象？

编辑 1

我将为不同的数据库表创建不同的类。每个类都应该有自己的 TABLENAME 变量，也不例外。每次创建扩展抽象类的新类时，我都必须确保这个变量是静态的。

然后在抽象类中我会有一个方法 eg：init();

如果在这个 init() 方法中我调用 TABLENAME，它应该从子类中获取值。

这样的事情也应该可以解决

String tablename=(clsAbstract)objItem.TABLENAME;
// where objItem can be any class that extended clsAbstract;

编辑 2

我想要在每个类中定义一个常量（静态），并在抽象中定义它的名称。

• 我在摘要中定义了变量 TABLENAME，但没有给出值。
• 我创建了一个 clsContactGroups，应该会提示我实现 TABLENAME，这是获取一些数据的地方。例如：TABLENAME="contactgroups";
• 我创建了第二个类 clsContacts，应该会提示我实现 TABLENAME，这是获取一些数据的地方。例如：TABLENAME="联系人";
  等等……

Answer 1

在设置字段的抽象类中定义一个构造函数，以便具体实现符合调用/覆盖构造函数所需的规范。

例如

public abstract class AbstractTable {
    protected String name;

    public AbstractTable(String name) {
        this.name = name;
    }
}

当你扩展 AbstractTable 时，在你添加一个调用 super("somename") 的构造函数之前，类不会编译。

public class ConcreteTable extends AbstractTable {
    private static final String NAME = "concreteTable";

    public ConcreteTable() {
        super(NAME);
    }
}

这种方式要求实现者设置name。这样，您还可以在抽象类的构造函数中进行（空）检查，以使其更加健壮。例如：

public AbstractTable(String name) {
    if (name == null) throw new NullPointerException("Name may not be null");
    this.name = name;
}

Answer 2

我认为您的困惑在于 C# 属性与字段/变量。在 C# 中，您不能定义抽象字段，即使在抽象类中也是如此。但是，您可以定义抽象属性，因为它们是有效的方法（例如，编译为 get_TAG() 和 set_TAG(...)）。

正如一些人所提醒的，你的类中不应该有公共字段/变量，即使在 C# 中也是如此。几个答案暗示了我的建议，但没有说清楚。您应该使用 getTAG() 将您的想法作为 JavaBean 属性转换为 Java。然后你的子类必须实现这个（我也写了一个表类的项目）。

所以你可以像这样定义一个抽象类...

public abstract class AbstractTable {

    public abstract String getTag();
    public abstract void init();

    ...
}

然后，在任何具体的子类中，您都需要定义一个静态最终变量（常量）并从getTag() 返回，如下所示：

public class SalesTable extends AbstractTable {

    private static final String TABLE_NAME = "Sales";

    public String getTag() {
        return TABLE_NAME;
    }

    public void init() {
        ...
        String tableName = getTag();
        ...
    }

}

编辑：

您不能覆盖继承的字段（在 C# 或 Java 中）。也不能覆盖静态成员，无论它们是字段还是方法。所以这也是最好的解决方案。我更改了上面的 init 方法示例以展示如何使用它 - 再次将 getXXX 方法视为一个属性。

Answer 3

在 Java（或 C++）中没有抽象变量之类的东西。

如果父类有变量，而子类扩展了父类，则子类不需要实现该变量。它只需要访问父实例。获取/设置或受保护的访问都可以。

“...所以应该提示我实现摘要”？如果你扩展了一个抽象类并且没有实现一个抽象方法，编译器会告诉你要么实现它，要么将子类标记为抽象。这就是您将得到的所有提示。

Answer 4

您能做的最好的事情就是为变量设置访问器/修改器。
getTAG()
之类的东西 这样，所有实现类都必须实现它们。

抽象类用于定义抽象行为而不是数据。

Answer 5

只需将此方法添加到基类中

public abstract class clsAbstractTable {

    public abstract String getTAG();
    public abstract void init();

}

现在每个扩展基类（并且不想成为抽象类）的类都应该提供一个标签

你也可以选择 BalusC 的回答

Answer 6

由于没有变量的实现，它不能是抽象的；）

Answer 7

为什么要所有子类都定义变量？如果每个子类都应该有它，只需在超类中定义它。顺便说一句，鉴于无论如何不公开字段是一种很好的 OOP 做法，您的问题就更没有意义了。

Answer 8

将代码改为：

public abstract class clsAbstractTable {
  protected String TAG;
  public abstract void init();
}

public class clsContactGroups extends clsAbstractTable {
  public String doSomething() {
    return TAG + "<something else>";
  }
}

这样，所有继承这个类的类都会有这个变量。你可以做 200 个子类，但仍然每个子类都有这个变量。

旁注：不要使用大写字母作为变量名；常识是所有大写标识符都指的是常量，即不可更改的数据。

Answer 9

要添加每个类的元数据，也许注释可能是正确的方法。

但是，您不能强制在接口中存在注释，就像您不能强制静态成员或特定构造函数的存在一样。

Answer 10

使用枚举来强制值以及保持绑定检查：

enum Speed {
    HIGH, LOW;
}
private abstract  class SuperClass {
    Speed speed;
    SuperClass(Speed speed) {
        this.speed = speed;
    }
}
private class ChildClass extends SuperClass {
    ChildClass(Speed speed) {
        super(speed);
    }
}

Answer 11

在我的实验中，Java 抽象类确实需要指定 abstract 关键字。反之则会提示“abstract modifier cannot be put here”的错误。 您可以像指定普通属性一样指定抽象属性。

public abstract class Duck implements Quackable, Observable {
    // observerList should keep the list of observers watching this duck 
    List<Observer> observerList;

    public AttackBehavior attackBehavior;
    public FlyBehavior flyBehavior;

    public Duck() {
        observerList = new ArrayList<Observer>();
    }
}

而在子类中，可以直接使用this.flyBehavior或this.attackBehavior这些属性。您不需要重写属性字段中的属性。

Answer 12

public abstract class Duck 
{
    /** This is not static. */
    private String duckName = "";

    /** Abstract Constructor. */
    public Duck(final String name) 
    {
        duckName = name;
    }

    /** Accessor method. */
    public String getName()
    {
         return duckName;
    }

    /** An example of an abstract method that has to be made concrete. */
    public abstract void fly(); 

}

然后你将有另一个类：

public class KhakiCampbell extends Duck
{
    // Constructor
    public KhakiCampbell(final String name)
    {
        super(name);
    }

    @Override
    public void fly()
    {
        /** Do something simple. */
       System.out.println(getName() + " is flying!");
    }
 
    /** This is something that only Khaki Cambell ducks do, of course, joke!. */
    public void crash()
    {
       /** Do something simple. */
       System.out.println(getName() + " has crashed!");
    }
 
    /** Keep going. */
    public void stillFly()
    {
        /** Do something simple. */
        System.out.println(getName() + " is still flying!");
    }

    public static void main(String[] args)
    {
        KhakiCampbell  duck = new KhakiCampbell("Bella");
        KhakiCampbell  mavis = new KhakiCampbell("Mavis");
        KhakiCampbell  boris = new KhakiCampbell("Boris");
        duck.fly();
        mavis.fly();
        boris.crash();
        mavis.stillFly();
    }
}

我在将上面的代码放入 Duck.java 和 KhakiCampbell.java 的单独文件名之后运行了上面的代码。在 Eclipse 中运行 KhakiCampbell 后，我在 java 控制台上看到了以下内容：
贝拉在飞！
Mavis 飞起来了！
鲍里斯坠毁了！
Mavis 还在飞！

我希望这能回答您的问题。您不需要任何静态变量声明。

Answer 13

不，Java 不支持抽象变量。这也没有多大意义。

您期望子类对变量的“实现”进行哪些具体更改？

当我在基类中有abstractString 变量时，子类应该怎么做才能使其非抽象？