重载 class 的构造函数，每个构造函数将具有不同的实例变量
Overloading constructor of a class and each constructor will have different instance variables
我最初想创建一个“方法”Min，它将搜索数组的 min 并返回两个元素。一个代表最小值，另一个代表这个 value.In 的索引 为了做到这一点，我决定创建一个 class Min 和一个构造函数，将这两个元素存储为实例变量，可以使用 getter 和 setter （双精度和整数）。
棘手的部分是，我想重载我的 class，并添加第二个构造函数，这个构造函数将使用 2D 数组作为输入并有两个其他实例变量（一个 double[]和一个 int[]).
它正在工作，但是我感到不舒服，因为我可以创建这个 class 的实例，例如使用第一个构造函数，并且仍然可以访问其他两个没有的变量对这个构造函数的意义，反之亦然。
我本可以为我的第二个构造函数创建一个完全不同的 class 来解决这个问题（例如：一个 class Min_array 和 Min_2Darray），但是我希望它们具有相同的名称，因为它代表相同类型的操作。
我相信应该有一种比我选择的方法更优雅的重载和检索多个结果的方法，我很乐意提供一些建议或知道什么是最好的做法。谢谢
我的第二个（更小的）问题是我必须在构造函数 2 中创建构造函数 1 的许多实例，这看起来很奇怪，并且在内存分配方面根本没有效率。
我的 class 分钟：
package operation;
public class Min {
// ---------------- Instance Variables ------------------
private int index = 0;
private double value = Double.POSITIVE_INFINITY; // important as i search for the MIN
private int[] ArrayIndex;
private double[] ArrayValue;
// ---------------- Constructor 01 ------------------
public Min(double [] anArray) {
for (int i = 0; i < anArray.length; i++) {
if (anArray[i] < this.value) {
this.value = anArray[i];
this.index = i;
}
}
}
// ---------------- Constructor 02 ------------------
public Min(double [][] a2DArray, boolean accordingToRow) {
int n_row = a2DArray.length;
int n_col = a2DArray[0].length;
if (accordingToRow == true) {
this.ArrayIndex = new int [n_row];
this.ArrayValue = new double [n_row];
for (int i = 0; i < n_row; i++) {
Min minofOneArray = new Min(a2DArray[i]); // Here i call and create multiple instance of constructor 01.
this.ArrayIndex[i] = minofOneArray.getIndex();
this.ArrayValue[i] = minofOneArray.getValue();
}
}else { // accordingToRow == false (so it according to Column now)
this.ArrayIndex = new int [n_col];
this.ArrayValue = new double [n_col];
//need to loop to extract a column in this case
double[] tmpArray = new double [n_row];
for (int j = 0; j < n_col; j++) {
for (int i = 0; i < n_row; i++) {
tmpArray[i] = a2DArray[i][j];
}
Min minofOneArray = new Min(tmpArray);
this.ArrayIndex[j] = minofOneArray.getIndex();
this.ArrayValue[j] = minofOneArray.getValue();
}
}
}
// ---------------- Getters & Setters ------------------
public int getIndex() {return this.index ; }
public double getValue() {return this.value ; }
public int[] getArrayIndex() {return this.ArrayIndex ; }
public double[] getArrayValue() {return this.ArrayValue ; }
}
我的测试 class Min :
package operation_test;
import java.util.Arrays;
import operation.Min;
class Test_MIN {
public static void main(String[] args) {
System.out.println(">>>>>>>>>>>>>>>>>>>>>>>> Test of the Min Class <<<<<<<<<<<<<<<<<<<<<<<<<<" );
double [] anArray = { 0, 2 , 1 , -2 , 5 };
Min minOfArray = new Min(anArray);
System.out.println(minOfArray.getIndex());
System.out.println(minOfArray.getValue());
System.out.println("--------------- End of test 01 -----------------" );
double [][] a2DArray = {{0.2,5,-1},{1,3,0.5}};
// 0 5 -1
// 1 3 0.5
Min minOf2DArray = new Min(a2DArray, true); // according to row
System.out.println(Arrays.toString(minOf2DArray.getArrayIndex()));
System.out.println(Arrays.toString(minOf2DArray.getArrayValue()));
System.out.println("--------------- End of test 02 -----------------" );
Min minOf2DArray_AccordingToCol = new Min(a2DArray, false); // according to column
System.out.println(Arrays.toString(minOf2DArray_AccordingToCol.getArrayIndex()));
System.out.println(Arrays.toString(minOf2DArray_AccordingToCol.getArrayValue()));
System.out.println("--------------- End of test 03 -----------------" );
}
}
我的 class 分钟的结果：
>>>>>>>>>>>>>>>>>>>>>>>> Test of the Min Class <<<<<<<<<<<<<<<<<<<<<<<<<<
3
-2.0
--------------- End of test 01 -----------------
[2, 2]
[-1.0, 0.5]
--------------- End of test 02 -----------------
[0, 1, 0]
[0.2, 3.0, -1.0]
--------------- End of test 03 -----------------
如果您希望不同的构造函数使用不同的实例变量集设置实例，那么您需要创建不同 classes 的实例。那些可以继承基础 class 和公共部分。
(虽然很短，但已被 OP 和 @user 视为答案。我创建它是为了将问题从列表中删除未回答的问题。当创建更有帮助或技术上更详细的答案时让我知道。我不介意删除我的答案。)
我尝试了一些不同的东西，它更适合我表达的担忧：
我post这里的代码如果它对某人有用。
想法是使用 class“元组”来检索多个输出，因此我不需要传递给构造函数。我仍然可以创建一个独特的 class 将这两种方法作为静态方法。
但是，我还是不知道哪种方法最好，我想这取决于应用的方式。
class 元组：
package utilitary;
public class Tuple<T, U> {
private final T first;
private final U second;
public Tuple(T first, U second) {
this.first = first;
this.second = second;
}
public T getFirst() {
return this.first;
}
public U getSecond() {
return this.second;
}
@Override
public String toString() {
return this.first + " " + this.second;
}
}
我的新 class 分钟：
package operation;
import utilitary.Tuple;
public class Min {
// ---------------- Method 01 ------------------
public static Tuple<Integer, Double> Min_Array(double [] anArray) {
int index = 0;
double value = Double.POSITIVE_INFINITY; // important as i search for the MIN
for (int i = 0; i < anArray.length; i++) {
if (anArray[i] < value) {
value = anArray[i];
index = i;
}
}
return new Tuple<>(index, value);
}
// ---------------- Method 02 ------------------
public static Tuple<int[], double[]> Min_2DArray(double [][] a2DArray, boolean accordingToRow) {
int[] arrayIndex;
double[] arrayValue;
int n_row = a2DArray.length;
int n_col = a2DArray[0].length;
if (accordingToRow == true) {
arrayIndex = new int [n_row];
arrayValue = new double [n_row];
for (int i = 0; i < n_row; i++) {
Tuple<Integer, Double> minofOneArray = Min_Array(a2DArray[i]); // Here i call method 01 multiple time
arrayIndex[i] = minofOneArray.getFirst();
arrayValue[i] = minofOneArray.getSecond();
}
}else { // accordingToRow == false (so it according to Column now)
arrayIndex = new int [n_col];
arrayValue = new double [n_col];
//need to loop to extract a column in this case
double[] tmpArray = new double [n_row];
for (int j = 0; j < n_col; j++) {
for (int i = 0; i < n_row; i++) {
tmpArray[i] = a2DArray[i][j];
}
Tuple<Integer, Double> minofOneArray = Min_Array(tmpArray);
arrayIndex[j] = minofOneArray.getFirst();
arrayValue[j] = minofOneArray.getSecond();
}
}
return new Tuple<>(arrayIndex, arrayValue);
}
}
测试：
package operation_test;
import java.util.Arrays;
import operation.Min;
import utilitary.Tuple;
class Test_MIN {
public static void main(String[] args) {
System.out.println(">>>>>>>>>>>>>>>>>>>>>>>> Test of the Min Class <<<<<<<<<<<<<<<<<<<<<<<<<<" );
double [] anArray = { 0, 2 , 1 , -2 , 5 };
Tuple<Integer, Double> minOfArray = Min.Min_Array(anArray);
System.out.println(minOfArray.getFirst());
System.out.println(minOfArray.getSecond());
System.out.println("--------------- End of test 01 -----------------" );
double [][] a2DArray = {{0.2,5,-1},{1,3,0.5}};
// 0.2 5 -1
// 1 3 0.5
Tuple<int[], double[]> minOf2DArray = Min.Min_2DArray(a2DArray, true);
System.out.println(Arrays.toString(minOf2DArray.getFirst()));
System.out.println(Arrays.toString(minOf2DArray.getSecond()));
System.out.println("--------------- End of test 02 -----------------" );
Tuple<int[], double[]> minOf2DArray_AccordingToCol = Min.Min_2DArray(a2DArray, false);
System.out.println(Arrays.toString(minOf2DArray_AccordingToCol .getFirst()));
System.out.println(Arrays.toString(minOf2DArray_AccordingToCol.getSecond()));
System.out.println("--------------- End of test 03 -----------------" );
}
}
结果
>>>>>>>>>>>>>>>>>>>>>>>> Test of the Min Class <<<<<<<<<<<<<<<<<<<<<<<<<<
3
-2.0
--------------- End of test 01 -----------------
[2, 2]
[-1.0, 0.5]
--------------- End of test 02 -----------------
[0, 1, 0]
[0.2, 3.0, -1.0]
--------------- End of test 03 -----------------
我最初想创建一个“方法”Min，它将搜索数组的 min 并返回两个元素。一个代表最小值，另一个代表这个 value.In 的索引 为了做到这一点，我决定创建一个 class Min 和一个构造函数，将这两个元素存储为实例变量，可以使用 getter 和 setter （双精度和整数）。
棘手的部分是，我想重载我的 class，并添加第二个构造函数，这个构造函数将使用 2D 数组作为输入并有两个其他实例变量（一个 double[]和一个 int[]).
它正在工作，但是我感到不舒服，因为我可以创建这个 class 的实例，例如使用第一个构造函数，并且仍然可以访问其他两个没有的变量对这个构造函数的意义，反之亦然。
我本可以为我的第二个构造函数创建一个完全不同的 class 来解决这个问题（例如：一个 class Min_array 和 Min_2Darray），但是我希望它们具有相同的名称，因为它代表相同类型的操作。
我相信应该有一种比我选择的方法更优雅的重载和检索多个结果的方法，我很乐意提供一些建议或知道什么是最好的做法。谢谢
我的第二个（更小的）问题是我必须在构造函数 2 中创建构造函数 1 的许多实例，这看起来很奇怪，并且在内存分配方面根本没有效率。
我的 class 分钟：
package operation;
public class Min {
// ---------------- Instance Variables ------------------
private int index = 0;
private double value = Double.POSITIVE_INFINITY; // important as i search for the MIN
private int[] ArrayIndex;
private double[] ArrayValue;
// ---------------- Constructor 01 ------------------
public Min(double [] anArray) {
for (int i = 0; i < anArray.length; i++) {
if (anArray[i] < this.value) {
this.value = anArray[i];
this.index = i;
}
}
}
// ---------------- Constructor 02 ------------------
public Min(double [][] a2DArray, boolean accordingToRow) {
int n_row = a2DArray.length;
int n_col = a2DArray[0].length;
if (accordingToRow == true) {
this.ArrayIndex = new int [n_row];
this.ArrayValue = new double [n_row];
for (int i = 0; i < n_row; i++) {
Min minofOneArray = new Min(a2DArray[i]); // Here i call and create multiple instance of constructor 01.
this.ArrayIndex[i] = minofOneArray.getIndex();
this.ArrayValue[i] = minofOneArray.getValue();
}
}else { // accordingToRow == false (so it according to Column now)
this.ArrayIndex = new int [n_col];
this.ArrayValue = new double [n_col];
//need to loop to extract a column in this case
double[] tmpArray = new double [n_row];
for (int j = 0; j < n_col; j++) {
for (int i = 0; i < n_row; i++) {
tmpArray[i] = a2DArray[i][j];
}
Min minofOneArray = new Min(tmpArray);
this.ArrayIndex[j] = minofOneArray.getIndex();
this.ArrayValue[j] = minofOneArray.getValue();
}
}
}
// ---------------- Getters & Setters ------------------
public int getIndex() {return this.index ; }
public double getValue() {return this.value ; }
public int[] getArrayIndex() {return this.ArrayIndex ; }
public double[] getArrayValue() {return this.ArrayValue ; }
}
我的测试 class Min :
package operation_test;
import java.util.Arrays;
import operation.Min;
class Test_MIN {
public static void main(String[] args) {
System.out.println(">>>>>>>>>>>>>>>>>>>>>>>> Test of the Min Class <<<<<<<<<<<<<<<<<<<<<<<<<<" );
double [] anArray = { 0, 2 , 1 , -2 , 5 };
Min minOfArray = new Min(anArray);
System.out.println(minOfArray.getIndex());
System.out.println(minOfArray.getValue());
System.out.println("--------------- End of test 01 -----------------" );
double [][] a2DArray = {{0.2,5,-1},{1,3,0.5}};
// 0 5 -1
// 1 3 0.5
Min minOf2DArray = new Min(a2DArray, true); // according to row
System.out.println(Arrays.toString(minOf2DArray.getArrayIndex()));
System.out.println(Arrays.toString(minOf2DArray.getArrayValue()));
System.out.println("--------------- End of test 02 -----------------" );
Min minOf2DArray_AccordingToCol = new Min(a2DArray, false); // according to column
System.out.println(Arrays.toString(minOf2DArray_AccordingToCol.getArrayIndex()));
System.out.println(Arrays.toString(minOf2DArray_AccordingToCol.getArrayValue()));
System.out.println("--------------- End of test 03 -----------------" );
}
}
我的 class 分钟的结果：
>>>>>>>>>>>>>>>>>>>>>>>> Test of the Min Class <<<<<<<<<<<<<<<<<<<<<<<<<<
3
-2.0
--------------- End of test 01 -----------------
[2, 2]
[-1.0, 0.5]
--------------- End of test 02 -----------------
[0, 1, 0]
[0.2, 3.0, -1.0]
--------------- End of test 03 -----------------
如果您希望不同的构造函数使用不同的实例变量集设置实例，那么您需要创建不同 classes 的实例。那些可以继承基础 class 和公共部分。
(虽然很短，但已被 OP 和 @user 视为答案。我创建它是为了将问题从列表中删除未回答的问题。当创建更有帮助或技术上更详细的答案时让我知道。我不介意删除我的答案。)
我尝试了一些不同的东西，它更适合我表达的担忧：
我post这里的代码如果它对某人有用。
想法是使用 class“元组”来检索多个输出，因此我不需要传递给构造函数。我仍然可以创建一个独特的 class 将这两种方法作为静态方法。
但是，我还是不知道哪种方法最好，我想这取决于应用的方式。
class 元组：
package utilitary;
public class Tuple<T, U> {
private final T first;
private final U second;
public Tuple(T first, U second) {
this.first = first;
this.second = second;
}
public T getFirst() {
return this.first;
}
public U getSecond() {
return this.second;
}
@Override
public String toString() {
return this.first + " " + this.second;
}
}
我的新 class 分钟：
package operation;
import utilitary.Tuple;
public class Min {
// ---------------- Method 01 ------------------
public static Tuple<Integer, Double> Min_Array(double [] anArray) {
int index = 0;
double value = Double.POSITIVE_INFINITY; // important as i search for the MIN
for (int i = 0; i < anArray.length; i++) {
if (anArray[i] < value) {
value = anArray[i];
index = i;
}
}
return new Tuple<>(index, value);
}
// ---------------- Method 02 ------------------
public static Tuple<int[], double[]> Min_2DArray(double [][] a2DArray, boolean accordingToRow) {
int[] arrayIndex;
double[] arrayValue;
int n_row = a2DArray.length;
int n_col = a2DArray[0].length;
if (accordingToRow == true) {
arrayIndex = new int [n_row];
arrayValue = new double [n_row];
for (int i = 0; i < n_row; i++) {
Tuple<Integer, Double> minofOneArray = Min_Array(a2DArray[i]); // Here i call method 01 multiple time
arrayIndex[i] = minofOneArray.getFirst();
arrayValue[i] = minofOneArray.getSecond();
}
}else { // accordingToRow == false (so it according to Column now)
arrayIndex = new int [n_col];
arrayValue = new double [n_col];
//need to loop to extract a column in this case
double[] tmpArray = new double [n_row];
for (int j = 0; j < n_col; j++) {
for (int i = 0; i < n_row; i++) {
tmpArray[i] = a2DArray[i][j];
}
Tuple<Integer, Double> minofOneArray = Min_Array(tmpArray);
arrayIndex[j] = minofOneArray.getFirst();
arrayValue[j] = minofOneArray.getSecond();
}
}
return new Tuple<>(arrayIndex, arrayValue);
}
}
测试：
package operation_test;
import java.util.Arrays;
import operation.Min;
import utilitary.Tuple;
class Test_MIN {
public static void main(String[] args) {
System.out.println(">>>>>>>>>>>>>>>>>>>>>>>> Test of the Min Class <<<<<<<<<<<<<<<<<<<<<<<<<<" );
double [] anArray = { 0, 2 , 1 , -2 , 5 };
Tuple<Integer, Double> minOfArray = Min.Min_Array(anArray);
System.out.println(minOfArray.getFirst());
System.out.println(minOfArray.getSecond());
System.out.println("--------------- End of test 01 -----------------" );
double [][] a2DArray = {{0.2,5,-1},{1,3,0.5}};
// 0.2 5 -1
// 1 3 0.5
Tuple<int[], double[]> minOf2DArray = Min.Min_2DArray(a2DArray, true);
System.out.println(Arrays.toString(minOf2DArray.getFirst()));
System.out.println(Arrays.toString(minOf2DArray.getSecond()));
System.out.println("--------------- End of test 02 -----------------" );
Tuple<int[], double[]> minOf2DArray_AccordingToCol = Min.Min_2DArray(a2DArray, false);
System.out.println(Arrays.toString(minOf2DArray_AccordingToCol .getFirst()));
System.out.println(Arrays.toString(minOf2DArray_AccordingToCol.getSecond()));
System.out.println("--------------- End of test 03 -----------------" );
}
}
结果
>>>>>>>>>>>>>>>>>>>>>>>> Test of the Min Class <<<<<<<<<<<<<<<<<<<<<<<<<<
3
-2.0
--------------- End of test 01 -----------------
[2, 2]
[-1.0, 0.5]
--------------- End of test 02 -----------------
[0, 1, 0]
[0.2, 3.0, -1.0]
--------------- End of test 03 -----------------