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

我需要一个父公共抽象类，它将有多个子公共静态类。我只需要一个武器类的实例，几个静态类Bow，swar<等，它们扩展了父类，也只能存在于一个实例中（至少我需要能够获得它们的静态封地）。如何做好这件事

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（swarm.type）但不是这个
系统.out.println（武器.剑.类型）。这是否意味着我无法通过父抽象访问子对象？
如果一个对象只能存在于一个实例中（即我的werehouse中只有一把剑），这并不意味着它应该是一个静态类。它应该仍然是一个对象。如果在某个宇宙事件中，你最好的朋友铁匠明天会给你一把免费的剑呢？那么你会怎么做呢？
在Java中，只有嵌套类可以是静态的，这也并不意味着你认为它意味着什么。如果某个对象应该只有一个实例，那么您真正想要做的是使用单例模式：
如果您必须实现此模型，那么您需要考虑嵌套：

public abstract  class Weapon {

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

如果希望静态访问Bow类的单个实例，可以使Bow类具有非公共构造函数并初始化它的公共静态实例。（
public static Bow THE_Bow=new Bow（…）；
）这应该能够满足您的静态和继承需求。如果这不合理，请告诉我，我将提供一个代码示例。
我认为您没有理解static关键字的含义。我是Java新手，所以我不得不自己去查。（这也是我经常浏览这个网站的原因之一……我也学到了很多东西）。我在书签中找到了一个详细解释静态关键字的站点。祝您的项目好运。
您不能在父类作用域之外声明公共静态类。试着这样做

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

    public static class Sword extends Test{

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

        }

    }
}

一个实例可以通过将武器类的构造函数设置为私有并使用getInstance（）方法创建该类的单个实例来实现。这就是所谓的单例模式，但如果您的设计确实需要其他模式，请将其设置为单例模式。不要这样做，因为这将使您的代码难以编写测试，也难以进行将来的更改。
这不是一种
枚举模式吗

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;
  }
}

最好的方法是为你的“职业武器”使用单例模式

将构造函数设置为私有，并使用getInstance（）方法检索武器实例。在此之后，创建弓和剑的子类。
您可以使用子类作为静态类，如下所示

public class Bow extends  Weapon {

  private static Bow object = null;

  public Bow(){
    object = this;
  }

  public static getObjectAsStatic(){
    return object;
  }

}

现在，您可以调用任何具有“Bow.getObjectAsStatic（）”的类成员，如Bow.getObjectAsStatic（）.classMembers
，
Swarm
类的代码在哪里？通过尝试使用武器.swarm.type，您似乎认为通过“扩展”派生类和嵌套类是同一回事。事实并非如此。第一种创造了一种“是”的关系；剑是一种武器。第二种创造了一种“有”的关系；武器有剑。点运算符允许您访问字段、方法等。对象具有，而不是从给定对象的同一类派生的其他类。您不应强制自己拥有对象的单个实例。有一个单独的实例，传递它是可以的，但不要强迫它。我自己也讨厌单身汉，但考虑到主题，我不想在单身汉不好的原因变得有意义之前，与需要更多了解基本OOP的人讨论架构。这并不意味着你应该用邪恶腐蚀他的心灵！嘘！克图鲁！嘘！！！我的回答假设您不是有意只想要类的一个实例（这是static关键字的常用用法）。