0

坦率地说，这是家庭作业的一部分。我根本不想作弊。相反，我已经完成了大约 60% 的作业，现在我被困住了，因为我不明白规范中对我必须编写/使用的一种方法的要求。

背景： 作业涉及编写一个包含 2 个类的程序，一个是 main，另一个是 VectorADT。VectorADT 类（简而言之）应该有两个实例变量数组（在此赋值范围内是“向量”）以及一些用于操作这两个数组的实例方法（也存在一些静态方法）。

我的问题： 我必须编写的一种方法是通过添加数组的相应插槽来将两个向量（在这种情况下为数组）相加。假设两个数组的大小相同！我设法完成了所有这些，然后我被要求返回一个 VectorADT，其中包含两个给定 VectorADT 参数 (v1 + v2) 的总和。返回 VectorADT 是什么意思？这不是班级的名字吗？在这种情况下，我传递给这个 add 方法的对象的类型是什么？我实际上不明白我的 return 语句应该在 add 方法中是什么，以及我应该将 return 分配给什么（在我的 main 方法中）。

方法规范： public static VectorADT add(VectorADT v1, VectorADT v2) 生成并返回两个给定 VectorADT 的总和。注意向量加法是通过将每个向量的对应元素相加得到和向量的对应元素来定义的。

参数： v1 - 第一个 VectorADT v2 - 第二个 VectorADT

前提条件：v1和v2引用的VectorADT对象已经实例化，并且大小相同。

返回： 包含两个给定 VectorADT 参数 (v1 + v2) 之和的 VectorADT。

抛出： IllegalArgument - 指示 v1 或 v2 为空。InvalidSizeException - 表示 v1 和 v2 的大小不同。

我写的代码：

class VectorOperations
{
    public static void main(String[] args)
    {
        //blue and yellow are used as an example here.
        int [] blue = new int [12]; 
        int [] yellow = new int [12];

        //initializes vector array using constructor
        VectorADT one = new VectorADT(blue);  

        //initializes vector array using constructor
        VectorADT two = new VectorADT(yello);

        //what am i supposed assign my return to?
        something????? = VectorADT.add(one, two);
    }
}

public class VectorADT
{
    private int [] vector;
    public VectorADT(int [] intArray)
    {
    //constructor that initializes instance variable vector.
    //vector ends up being the same size as the array in the 
    //constructors parameter. All slots initialized to zero.
    }
    public static VectorADT add(VectorADT one, VectorADT two) 
    {               //I used one and two instead of v1 and v2

       //some if statements and try-catch blocks for exceptions i need
       //if no exceptions thrown...
       int [] sum = new int [one.vector.length];  //one and two are same length
       for(int i = 0; i < one.vector.length; i++)
       {
           sum[i] = one.vector[i] + two.vector[i];
       }
       return //Totally confused here  :(
    }

    //other methods similar to VectorADT add() also exist...
}

任何帮助或指导将不胜感激。谢谢

4

5 回答 5

1

理解上的脱节似乎是因为方法本身不返回类，但它们可以返回类的实例（对象）。

public static VectorADT add(VectorADT one, VectorADT two)

此方法签名表明此方法接受两个 VectorADT 类型的对象，并返回一些同样为 VectorADT 类型的对象。据推测，返回的这个对象将是您在方法中的某个点创建的一些新对象，目的是将其返回给调用您的方法的任何对象。

VectorADT myVectorADT = new myVectorADT(..) //define a new object
//Do some stuff to make myVectorADT have the proper values, for example summing vector one and two's elements
return myVectorADT;  //return it!

首先确保检查每个提供的对象不为空

if (one == null || two == null) //throw something

然后简单地说，在您的方法中，创建一个新向量，用向量 1 + 向量 2 的元素填充它，然后如上所示返回它。

这是一个可能有帮助的例子，它是自包含的

class A {
    public int value;
    public A(int k) {  //Constructor
        value = k;
    }
}

现在让我们定义一个像你上面的方法

public static A addMethod (A one, A two) { //Method returns class type A, accepts two variables of type A
    A returnObject = new A(one.value + two.value);
    return returnObject;
}

这是一个简单的示例，但老实说，它与您所拥有的几乎相同。现在可以像下面这样调用上述方法：

A firstObject = new A(5);
A secondObject = new A(3);
A newObject = addMethod(firstObject, secondObject);

System.out.println(newObject.value); //prints 8
于 2013-07-14T19:32:16.820 回答
0

关键是您需要构建一个新的VectorADT.

使用以下方法创建它：

VectorATD vec=new VectorADT(sum);

如果需要，您现在可以调用它的方法来修改它。

然后，

return vec;
于 2013-07-14T19:33:40.510 回答
0

您应该返回一个新的 VectorADT 对象。

当您被要求返回包含两个给定 VectorADT 参数 (v1 + v2) 之和的 VectorADT 时，实际上是要求您返回VectorADT 类的一个对象，一个新实例，而不是类本身。

在您的情况下，您可以像这样创建 add 方法：

public static VectorADT add(VectorADT one, VectorADT two) 
{
   int [] sum = new int [one.vector.length];
   for(int i = 0; i < one.vector.length; i++)
   {
       sum[i] = one.vector[i] + two.vector[i];
   }
   return new VectorADT(sum);
}

在主要方法：

VectorADT sum = VectorADT.add(one, two);

其中“sum”是您想要的保存 VectorADT 对象的变量的名称。

当您放置 时new VectorADT(sum)，您正在调用构造函数，即public VectorADT(int [] intArray). 如您所见，它接收一个int[]，并且如您所说，将其放入实例变量向量中。您将传递给它int[] sum以接收两个向量的总和 ( sum[i] = one.vector[i] + two.vector[i];)

当您将其作为方法的返回时，它会返回您刚刚使用该方法的两个参数之和创建的新 VectorADT 对象，无论您在何处调用它。因此，当您在 main 中调用它时，该方法将返回一个新的VectorADT，您将VectorADT作为您声明的变量的类型 ( VectorADT sum = VectorADT.add(one, two);)。

希望现在很清楚。

于 2013-07-14T19:34:01.590 回答
0

看来您应该返回一个新的 VectorADT 实例，其向量是您计算的总和数组。

简直了return new VectorADT(sum);

这是向量数学中的常见操作。两个向量的和是第三向量，其分量是加数向量中两个对应分量的和。

于 2013-07-14T19:31:43.703 回答
0 
public class AddVector {
     public static void main(String[] args)
        {
            //blue and yellow are used as an example here.
            int [] blue = {1,4,3,2,}; 
            int [] yellow = {3,5,6,4};
            //initializes vector array using constructor
            VectorADT one = new VectorADT(blue);  
            //initializes vector array using constructor
            VectorADT two = new VectorADT(yellow);
            //what am i supposed assign my return to?
            int sum = VectorADT.add(one, two);
            System.out.println("Sum of vector is : "+sum);
        }    
}

class VectorADT
{
    private int [] vector;
    public VectorADT(int [] intArray)
    {
        vector = intArray;
    }
    public static int add(VectorADT one, VectorADT two) 
    {               
       int total = 0;
       if(one.vector.length == two.vector.length){
           for(int i = 0; i < one.vector.length; i++)
           {
               total += one.vector[i] + two.vector[i];
           }
           return total;
       }else{
           return 0;
       }
    }
}
于 2013-07-14T20:04:48.470 回答