Java 卡片不是抽象错误吗？

我创建了一个程序，可以扩展给定的类。然而，我得到了一个错误，指出程序不是抽象的，而无论如何它都不应该是抽象的

这是我试图解决的问题：

一副标准的扑克牌由52张牌组成。每张牌都有一个等级和一套衣服。您将创建一个名为Card的类，该类将模拟标准卡组中的卡。您的类将扩展AbstractCard类（提供）

标准牌组中的牌的顺序（如本任务所定义）首先由套牌指定，如果套牌相同，则由等级指定

西服和军衔的顺序如下： 西服：西服将被订购 钻石<梅花<红心<黑桃

等级：将对等级进行排序 2<3<··<9<10 小丑牌是一种比牌组中任何其他牌都“大”的特殊牌（任何两个小丑都相等）。小丑没有西装（AbstractCard.suites中的“无”）

同样，非小丑卡的总体顺序是先穿西装，然后排名；例如，所有俱乐部卡“少于”所有心脏卡。两张等级和花色相同的牌被认为是相等的

编写一个名为Card的Java类，扩展提供的Card类。您的类必须有两个构造函数：

公共卡（串级、串套装）

用途：创建具有给定等级和套装的卡

前提条件：西服必须是卡牌中的字符串。西服等级必须是卡牌中的字符串。等级

注意：如果等级为AbstractCard.RANKS[15]，则可以给出AbstractCard.Suites中的任何有效套装，但该卡的套装将设置为AbstractCard.Suites[4]

公共卡（国际等级，字符串套装）

用途：创建具有给定等级和套装的卡

前提条件：西服必须是卡中的字符串。西服

注意：与其他构造函数一样，如果创建了小丑，则可以传递任何有效的套装，但卡的套装将设置为AbstractCard.Suites[4]

注意字符串的大小写在这里很重要。输入字符串必须与AbstractCard.SUITS或AbstractCard.RANKS中的字符串完全相同

AbstractCard类中三种抽象方法的规范如下所示：

public int getRank（）

目的：以整数形式获取当前卡的排名

输出：卡片的等级

小丑->1，2->2，3->3，…，10->10

杰克->11，女王->12，国王->13，王牌->14

公共字符串getRankString（）

目的：以字符串形式获取当前卡的排名

将卡的等级作为Card.RANKS中的字符串之一返回（以与卡对应的字符串为准）

公共字符串getSuit（）

目的：获取当前卡的套装

将卡的套装作为card.SUITS中的字符串之一返回（以与卡对应的字符串为准）

抽象代码：

public abstract class AbstractCard implements Comparable<AbstractCard>{

 /* handy arrays for ranks and suits    */
 /* do NOT change these                 */
 public final static String[] RANKS = { "None", "None", 
   "2", "3", "4", "5", "6", "7", "8", "9", "10", 
   "Jack", "Queen", "King", "Ace", "Joker"};

 public final static String[] SUITS = { "Diamonds", "Clubs", "Hearts",         "Spades", "None"};



 /** the numerical representation of the rank of the current card
  *  <p>
  * ranks have the numerical values
  *  2 = 2, 3 = 3, ..., 10 = 10
  *  Jack = 11, Queen = 12, King = 13, Ace = 14
  * Joker = 1 
  * @return the numerical rank of this card 
  */
 public abstract int getRank();



 /** the string representation of the rank of the current card 
  *
  * @return the string representation of the rank of this card 
  *         (must be a string from Card.RANKS) 
  */
 public abstract String getRankString();


 /** the suit of the current card 
  *
  * @return the suit of this card (must be a string from Card.SUITS) 
  */
 public abstract String getSuit();



 @Override
 public final String toString(){
 // outputs a string representation of a card object
 int r = getRank();
 if( r >= 2 && r <= 14 ){
   return r + getSuit().substring(0,1);
 }else if (r == 1){
   return "J";
 }
 return "invalid card";
 }

}

public class Card extends AbstractCard { 

  public Card(String rank,String suit) {

this.strRank = rank;

this.suit = suit;

setIntRank();

}

public Card(int rank,String suit) {

this.intRank = rank;

this.suit = suit;

setStringRank();

}

private void setIntRank() {

String temp = strRank.toLowerCase();

switch(temp) {

case "jack":

intRank = 11;

break;

case "queen":

intRank = 12;

break;

case "king":

intRank = 13;

break;

case "ace":

intRank = 14;

break;

default:

intRank = Integer.parseInt(strRank);

break;

}

}

private void setStringRank() {

switch(intRank) {

case 11:

strRank="Jack";

break;

case 12:

strRank="Queen";

break;

case 13:

strRank="King";

break;

case 14:

strRank="Ace";

break;

default:

strRank = ""+intRank;

break;

}

}

public int getRank() {

return intRank;
}
public String getRankString() {

return strRank;

}
public String getSuit() {

return suit;

}

}

---

您需要实现由

Compariable

接口

定义的功能，而

AbstractCard

承诺遵守该接口

这意味着将方法

compareTo

添加到

AbstractCard

（可能更好）或

Card

@Override
public int compareTo(AbstractCard o) {
    // Your implementation
}

---

我建议从

接口开始，它将描述
卡
承诺提供的功能。然后，我将使用
抽象类来实现核心或公共功能（如
toString
和
compareTo
），然后进行具体实现。主要原因是，它将代码解耦到更高的程度，并允许在不影响依赖于
接口的代码的情况下更改实现，但这只是我；）
 我不认为
Card
实现了
compare
中的
compare
方法，我们不允许更改AbstractCard，如果将该方法添加到Card中会有很大的不同吗？@MuthuShank这意味着您必须在任何其他类中重新实现它（除了
Card
）这扩展了AbstractCard，这可能是浪费时间。如果您不打算编写任何其他这样的类，那么它应该不会有什么不同。@MuthuShank这并不是抽象应该如何工作，但是如果您在从
AbstractCard
扩展的每个类中都要实现抽象，那么您可以这样做，但是，这可能会导致问题，因为这是一个潜在的错误点（由于
compareTo
的一个实现可能与另一个不同-无意中）。有什么问题吗？没有，我会这样做吗？没有可能在我应该做什么方面得到任何帮助吗？完全不知道我必须做什么才能使这项工作符合问题的要求。@MuthuShank您必须实现
compareTo
方法。它需要确定当前obj的天气状况ect大于、小于或等于提供的对象