Java 如何设置列表的引用类型？

我是Java新手。我需要定义一个构造函数

MyArrayList（对象类型）

，以设置稍后添加到列表中的引用类型

构造函数的签名不能更改。另外，不允许我使用泛型

我试着这样做：

public class MyArrayList implements MyList {
private Object[] theList; // array of objects


public MyArrayList(Object type) {
    theList = new type[0];

}

---

由于

类型

不是类，因此得到一个编译错误。正确的方法是什么？

在Java中，这种情况的答案是“泛型”。 java官方网站是学习泛型的好地方

对于这个场景，您可以编写如下代码

列表界面

package test.generics;

public interface MyList<T> {
    T get(int index);
    void add(T input);
    void clear();
}

package test.generics；
公共接口MyList{
T-get（int-index）；
无效添加（T输入）；
无效清除（）；
}

实施

package test.generics;

public class MyArrayList<T> implements MyList<T> {

    private Object[] storage = new Object[10];
    private int index = 0;

    @SuppressWarnings("unchecked")
    @Override
    public T get(int index) {
        T temp = null;
        if (!(index < 10 && index >= 0)) {
            throw new IllegalArgumentException("Expected range 0 to 9");
        } else {
            temp = (T) storage[index];
        }
        return temp;
    }

    @Override
    public void add(T input) {
        if (index < 10) {
            storage[index++] = input;
        } else {
            throw new IllegalArgumentException("Only 10 items supported");
        }
    }

    @Override
    public void clear() {
        index = 0;
    }

}

package test.generics；
公共类MyArrayList实现MyList{
私有对象[]存储=新对象[10]；
私有整数指数=0；
@抑制警告（“未选中”）
@凌驾
公共T获取（整数索引）{
温度=零；
如果（！（索引<10&&index>=0））{
抛出新的IllegalArgumentException（“预期范围0到9”）；
}否则{
温度=（T）存储[索引]；
}
返回温度；
}
@凌驾
公共无效添加（T输入）{
如果（指数<10）{
存储[索引++]=输入；
}否则{
抛出新的IllegalArgumentException（“仅支持10项”）；
}
}
@凌驾
公共空间清除（）{
指数=0；
}
}

消费者

package test.generics;

public class Consumer {

    public static void main(String[] args) {
        MyList<Integer> intList = new MyArrayList<>();
        intList.add(10);
        System.out.println(intList.get(0));
        MyList<String> stringList = new MyArrayList<>();
        stringList.add("hello");
        System.out.println(stringList.get(0));
    }

}

package test.generics；
公共类消费者{
公共静态void main（字符串[]args）{
MyList intList=新的MyArrayList（）；
增加（10）；
System.out.println（intList.get（0））；
MyList stringList=新的MyArrayList（）；
stringList.add（“hello”）；
System.out.println（stringList.get（0））；
}
}

在Java中，这种情况的答案是“泛型”。 java官方网站是学习泛型的好地方

对于这个场景，您可以编写如下代码

列表界面

package test.generics;

public interface MyList<T> {
    T get(int index);
    void add(T input);
    void clear();
}

package test.generics；
公共接口MyList{
T-get（int-index）；
无效添加（T输入）；
无效清除（）；
}

实施

package test.generics;

public class MyArrayList<T> implements MyList<T> {

    private Object[] storage = new Object[10];
    private int index = 0;

    @SuppressWarnings("unchecked")
    @Override
    public T get(int index) {
        T temp = null;
        if (!(index < 10 && index >= 0)) {
            throw new IllegalArgumentException("Expected range 0 to 9");
        } else {
            temp = (T) storage[index];
        }
        return temp;
    }

    @Override
    public void add(T input) {
        if (index < 10) {
            storage[index++] = input;
        } else {
            throw new IllegalArgumentException("Only 10 items supported");
        }
    }

    @Override
    public void clear() {
        index = 0;
    }

}

package test.generics；
公共类MyArrayList实现MyList{
私有对象[]存储=新对象[10]；
私有整数指数=0；
@抑制警告（“未选中”）
@凌驾
公共T获取（整数索引）{
温度=零；
如果（！（索引<10&&index>=0））{
抛出新的IllegalArgumentException（“预期范围0到9”）；
}否则{
温度=（T）存储[索引]；
}
返回温度；
}
@凌驾
公共无效添加（T输入）{
如果（指数<10）{
存储[索引++]=输入；
}否则{
抛出新的IllegalArgumentException（“仅支持10项”）；
}
}
@凌驾
公共空间清除（）{
指数=0；
}
}

消费者

package test.generics;

public class Consumer {

    public static void main(String[] args) {
        MyList<Integer> intList = new MyArrayList<>();
        intList.add(10);
        System.out.println(intList.get(0));
        MyList<String> stringList = new MyArrayList<>();
        stringList.add("hello");
        System.out.println(stringList.get(0));
    }

}

package test.generics；
公共类消费者{
公共静态void main（字符串[]args）{
MyList intList=新的MyArrayList（）；
增加（10）；
System.out.println（intList.get（0））；
MyList stringList=新的MyArrayList（）；
stringList.add（“hello”）；
System.out.println（stringList.get（0））；
}
}

正如您所说，您不想使用泛型，您可以通过

数组#newInstance

（）动态创建数组。这是您的调整代码：

public class MyArrayList implements MyList {
    private Object[] theList;

    public MyArrayList(Object type) {
        // Adjust as you like
        int size = 0;
        // Dynamically create array of type "type"
        theList = (Object[]) Array.newInstance(type.getClass(), size);
    }
}

由于您在编译时不知道该类，因此只能将其用作

对象[]

，但是，一旦知道该类型，它在运行时将只允许真正类型的

类型

的元素，而不是任意的

对象

s

---

请注意，数组的大小是固定的。您不能只向它们添加元素，大小总是固定的，必须事先知道。如果需要更动态的结构，请使用类似于

List

（例如

ArrayList

或

LinkedList

）

然后，您可以只记住给定的

类型

对象，如果用户试图添加一个项目，您将检查类型的

元素实例，并且仅在返回
true
时添加，否则会抛出类似
IllegalArgumentException
之类的异常

或者，如前所述，为数组设置一个良好的固定大小。您还可以通过在构造函数中提供
size
参数来为用户提供该选择。
正如您所说的不希望使用泛型，您可以通过
数组#newInstance
（）动态创建数组。这是您的调整代码：

public class MyArrayList implements MyList {
    private Object[] theList;

    public MyArrayList(Object type) {
        // Adjust as you like
        int size = 0;
        // Dynamically create array of type "type"
        theList = (Object[]) Array.newInstance(type.getClass(), size);
    }
}

由于您在编译时不知道该类，因此只能将其用作
对象[]
，但是，一旦知道该类型，它在运行时将只允许真正类型的
类型
的元素，而不是任意的
对象
s


请注意，数组的大小是固定的。您不能只向它们添加元素，大小总是固定的，必须事先知道。如果需要更动态的结构，请使用类似于
List
（例如
ArrayList
或
LinkedList
）

然后，您可以只记住给定的
类型
对象，如果用户试图添加一个项目，您将检查类型

的

元素实例，并且仅在返回
true
时添加，否则会抛出类似
IllegalArgumentException
之类的异常

或者，如前所述，为数组设置一个良好的固定大小。您还可以通过在构造函数中提供
size
参数来为用户提供该选项。
使用gener