Java中的抽象变量？

Question

我来自 C#，在那里这很容易，而且是可能的。

我有这样的代码：

public abstract class clsAbstractTable {

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

}

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

我有这个类：

public class clsContactGroups extends clsAbstractTable {


}

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

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

编辑1

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

然后在抽象类中我将有一个方法，例如：init();

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

像这样的东西也应该解决

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

编辑2

我想要在每个类中定义一个常量（静态），其名称以抽象方式定义。

• 我抽象地定义了变量 TABLENAME，但没有给出值。
• 我创建了一个 clsContactGroups，系统应该提示我实现 TABLENAME，这是获取一些数据的地方。例如：TABLENAME =“联系人组”；
• 我创建了第二个类 clsContacts，系统应该提示我实现 TABLENAME，这是获取一些数据的地方。例如：TABLENAME =“联系人”；
  ETC...

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。通过这种方式，您还可以在抽象类的构造函数中进行 (null) 检查，以使其更加健壮。例如：

public AbstractTable(String name) {
    Objects.requireNonNull(name, "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关键字。反之，会提示“此处不能放置抽象修饰符”的错误。
您可以像普通属性一样指定抽象属性。

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 控制台上看到以下内容：
贝拉正在飞翔！
梅维斯正在飞翔！
鲍里斯坠毁了！
梅维斯还在飞翔！

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

Answer 13

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

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

当我在基类中有一个 abstract String 变量时，子类应该如何使其成为非抽象变量？