Question

免责声明：我是初学者，所以请随意指出...

我有一个由带有8个值的int数组组成的超类，现在我想创建一个子类来随机选择数组中的4个项目并将它们存储在另一个Object中。

超类：

public class SideDeck{
    public static final int MaxValue = 6;
    public static final int MinValue = -6;
    public static final int MaxArrayValue = 8;
    public final int[] sidecards = new int[MaxArrayValue];


    public SideDeck(){
        for(int i=0;i<MaxArrayValue;i++){
            sidecards[i]=0;
        }
    }

public SideDeck(int sidecards1,int sidecards2,int sidecards3,int sidecards4,int sidecards5,int sidecards6, int sidecards7, int sidecards8){
    sidecards[0]=sidecards1;
    sidecards[1]=sidecards2;
    sidecards[2]=sidecards3;
    sidecards[3]=sidecards4;
    sidecards[4]=sidecards5;
    sidecards[5]=sidecards6;
    sidecards[6]=sidecards7;
    sidecards[7]=sidecards8;
    }

    public boolean ValidSidedeck(){
        int check=0;
        if (sidecards[0]!=0) {
            for(int i=0;i<MaxArrayValue;i++){
                if ((sidecards[i] > MinValue) && (sidecards[i] < MaxValue)){
                    check=1;
                } else{
                    check=0;
                    break;
                }
            }
        } else {
            check=0;
        }

        if (check==1){
            return true;
        } else {
            return false;
        }
    }

    public String toString(){
        String s="";
        for(int i=0;i<MaxArrayValue;i++){
                s+=(" || Card n° " + (i+1) + " = " + sidecards[i]);
                }
        return s;
    }


    public void ResetSidedeck(){
        if (sidecards[0]!=0) {//why check it? what if we just run it?
            for(int i=0;i<MaxArrayValue;i++){
                sidecards[i]=0;
            }
        }

}
}

子类:(不确定该怎么做...）基本上它应该从.super中选择4个随机位置并将它们存储在这里，只是因为我不知道如何以这种方式创建对象。并且传递super作为构造函数似乎不正确，因为它将传递Object而不是数组（并且我不需要完整的数组）。主要的是，我想保持这样的超级锁，也许只是在那里添加一个方法，所以提取4个值...并将它们作为参数传递......？

import java.lang.Math;

public final class PlayableSideDeck extends SideDeck{
    private final static int MaxCArrayValue=4;
    public final int[] sidecardsPlay = new int[MaxCArrayValue];
    public PlayableSideDeck(SideDeck sidecards){
/*      sidecardsPlay[0]=0;
        sidecardsPlay[1]=0;
        sidecardsPlay[2]=0;
        sidecardsPlay[3]=0;*/
    //  SetDeck();//<-Can i call a private method in the constructor
    }




    public void SetDeck(){
/*          for(int j=0;j<4;j++){
                int position=(super.sidecards[PickDeck()]);//<--this is the main problem.. since it's gonna call the object i guess. 
                sidecards[j]=position;
                System.out.println(/*"i= " + i + *//* " ||| j= " + j + "|||| new sidecard= " + sidecards[j] + " |||| old sidecard=" + super.sidecards[PickDeck()]);
            }*/
                for(int j=0;j<MaxCArrayValue;j++){
                sidecardsPlay[j]=(super.sidecards[PickDeck()]);
                System.out.println(/*"i= " + i + */ " ||| j= " + j + "|||| new sidecard= " + sidecardsPlay[j] + " |||| old sidecard=" + super.sidecards[PickDeck()] + "|| random= " + PickDeck());
            }

    }

    public int PickDeck(){
        return ((int)(Math.random() * 8));
    }

    public String toString(){
    String s="";
    for(int i=0;i<MaxCArrayValue;i++){
            s+=(" || Card n° " + (i+1) + " = " + sidecards[i]);
            }
    return s;
    }
}

感谢。

Answer 1

我不确定你打算如何使用PlayableSideDeck，所以我会回答这两种方式，你可以选择最合适的答案。

首先，正如“有效Java”（作者Josh Bloch）所指出的那样，你应该赞成合成而不是继承。通过使用组合，您可以回答是否应该将SideDeck的实例传递给PlayableSideDeck的构造函数的问题 - 您将不得不继承任何{{1}的访问权限}}。无论如何，我建议阅读书中的第16项（google for it，有在线提供的副本），看看作文是否更符合你的需求。

其次，如果您决定使用继承，则不需要将SideDeck的实例传递给SideDeck的构造函数。这是因为当您创建PlayableSideDeck的实例时，您将自动创建PlayableSideDeck的实例。如果您没有自己明确地提供另一个这样的调用，Java中的所有构造函数都将隐式调用SideDeck（这是超类的默认构造函数）。例如，你可以像这样阻止对super（）的隐式调用：

super()

在此示例中，如果您调用public class BaseClass { protected String strValue; public BaseClass () { strValue = ""; } public BaseClass (String str) { strValue = str; } } public class SubClass extends BaseClass { private int intValue; SubClass (String str, int i) { super (str); intValue = i; // note that since strValue is protected, SubClass can access directly System.out.println ("strValue = " + strValue); } }，则会在控制台上看到strValue = foobar。

如果new SubClass ("foobar")没有零参数构造函数，事实上，您需要调用BaseClass，因为编译器无法弄清楚如何为您执行此操作。

另外，既然你问过，这里有一些其他提示和指示：

在构造函数super(str)中，您显式地将数组的所有值初始化为0，这不是必需的。它们已经全部为0.如果你需要将它们初始化为0，那么你最好通过调用SideDeck()来避免代码重复。说到这个，你可以将代码缩短到ResetSideDeck（一定要导入java.util.Arrays）。

是的，您可以从构造函数中调用私有方法 - 但只能是属于本地类的私有方法，而不是任何超类（但是，您可以调用受保护的超类方法）。

你没有检查Arrays.fill (sidecards, 0);是正确的，因为除非sidecards[0] == 0变得非常大，否则几乎没有效率。

您的类成员变量（例如MaxArrayValue）应该是私有的（如果您需要从子类访问它们，则可能受到保护）。使用getter / setter方法访问它们。

最后，Java命名约定会告诉您使用小写字母表示方法名称（例如setDeck，pickDeck，resetDeck等），对于更加惯用的Java，您可以将ValidaDeck重命名为isValidDeck（因为它返回一个布尔）。对于诸如MaxArrayValue之类的常量，惯例是使用所有大写字母之间的下划线，例如， MAX_ARRAY_VALUE。

希望这一切都有帮助！

Java - 数组的子类

1 个答案: