Question

我需要一个父公共抽象类，它将具有多个子公共静态类。我只需要一个Weapon类的实例，一些静态类Bow，Sword＆lt;扩展父级的等等，也只能存在于一个实例中（至少我需要能够得到它们的静态）。怎么做得好？

public abstract  class Weapon {
    ...
}
public static class Bow extends  Weapon { 
      static String type = "Bow ";
      static  int damage = 10;
}

public static class Sword extends  Weapon { 
      static String type = "Sword";
      static int damage = 10;
}

获取错误：

Illegal modifier for the class Sword; only public, abstract & final are permitted

我删除了静态并且有效：

public final class   Sword extends  Weapon { 
      static String type = "Sword";
      static int hitPointsTaken = 10;
}

我可以编译此System.out.println( Sword.type );但不能编译System.out.println( Weapon.Sword.type );。这是否意味着我无法通过父摘要访问孩子？

Answer 1

如果您必须实施此模型，那么您正在寻找嵌套：

public abstract  class Weapon {

    public static class Bow extends  Weapon { 
          static String type = "Bow ";
          static  int hitPointsTaken = 10;
    }
}

Answer 2

在Java中，只有嵌套类可以是静态的，并且它并不意味着你认为它意味着什么。如果某些事物只有一个实例，那么你真正想做的是使用单例模式：http://en.wikipedia.org/wiki/Singleton_pattern#Example

Answer 3

您不能在父类范围之外声明公共静态类。试试这样做

public abstract class Weapon {
    public abstract void usage();

    public static class Sword extends Test{

        @Override
        public void usage() {
            // TODO Auto-generated method stub

        }

    }
}

通过将Weapon类的构造函数设置为private并使用getInstance（）方法创建类的单个实例，可以实现一个实例。这被称为Singleton模式，但是如果你的设计确实需要其他方法，请将其设为单例，因为它会使你的代码难以编写测试以及未来的更改。

Answer 4

如果对象只能存在于一个实例中（即我的工作室中只有一把剑），并不意味着它应该是静态类。它应该仍然是一个对象。如果通过一些宇宙事件，你最好的朋友，铁匠会给你一个免费的Sword tommorow？那你会做什么？

Answer 5

如果要静态访问Bow类的单个实例，可以使Bow类具有非公共构造函数并初始化它的公共静态实例。（public static Bow THE_BOW = new Bow(...);）这应该照顾你的静态和继承欲望。如果这没有意义，请告诉我，我将提供一个代码示例。

Answer 6

我认为你很想理解static关键字的含义。我是Java的新手，所以我必须自己去查找。（这是我浏览这个网站的原因之一......我也学到了很多东西）。我在书签中找到了this: Secrets of Static in Java with Example网站，详细解释了static关键字。祝你的项目好运。

Answer 7

这不是enum模式吗？

public enum Weapon {
  Bow(10),
  Sword(10);

  private int damage;

  Weapon (int damage) {
    this.damage = damage;
  }

  public int getDamage () {
    return damage;
  }
}

添加 ...或更显着

public enum Weapon {
  Bow(10) {
    @Override
    public void strike(Warrior warrior) {
      // Inflict the normal damage.
      super.strike(warrior);
      // Sometimes also sicken.
      if ( Math.random() > .95 ) {
        warrior.sicken(Illness.ArrowInTheKnee);
      }
    }
  },
  Sword(10) {
    @Override
    public void strike(Warrior warrior) {
      // Inflict the normal damage.
      super.strike(warrior);
      // Sometimes also sicken.
      if ( Math.random() > .75 ) {
        warrior.sicken(Illness.StabInTheBack);
      }
    }
  };

  // Normal damage inflicted.
  private int damage;

  Weapon(int damage) {
    this.damage = damage;
  }

  public int getDamage() {
    return damage;
  }

  public void strike(Warrior warrior) {
    warrior.inflict(damage);
  }

  // Placeholder
  public interface Warrior {
    public void inflict(int damage);
    public void terrorise(int fear);
    public void sicken (Illness illness);
  }

  enum Illness {
    StabInTheBack,
    ArrowInTheKnee;
  }
}

Answer 8

最好的方法是使用单身模式为你的“阶级武器”。

使您的构造函数成为私有，并使用getInstance（）方法来检索您的Weapon实例。在此之后为Bow and Sword创建子类。

Answer 9

你可以使用子类作为静态类，如下面的

public class Bow extends  Weapon {

  private static Bow object = null;

  public Bow(){
    object = this;
  }

  public static getObjectAsStatic(){
    return object;
  }

}

现在你可以使用＆＃34; Bow.getObjectAsStatic（）＆＃34;来调用任何类成员。像Bow.getObjectAsStatic（）。classMembers

如何定义扩展父抽象的子静态类？

9 个答案: