Java：将属性声明为Java给定类型或自写类型（可能有接口？）

我有一个关于Java的初学者问题

我有一个类

东西

，它有一个属性“attribute”。 我希望属性是

LinkedList

（由Java提供）或名为

My_type

的自定义类型，具体取决于提供给

Thing

构造函数的布尔值。像这样：

public class Thing<T> {
    private ??? attribute;  // Type is not given yet. How do I do this?

    public Thing(boolean which) {
        if (which)
            attribute = new LinkedList<T>();
        else
            attribute = new My_Type<T>();
    }

   ...
}

我会写

    private LinkedListOrMy_Type<T> attribute;

private LinkedListOrMy_类型属性；

一切都会好起来的。但是因为我不能修改

LinkedList

的代码，所以我不知道如何解决这个问题。有什么建议吗

---

让

My_Type

实现

List

接口（由Java提供）也不是一个选项，因为有太多的方法需要实现到

My_Type

中。但是我只想要添加和删除。我知道这是一个可能的解决方法-我可以让

My_Type

在列表的每个方法中抛出

不支持操作异常

，除了

添加

和

删除

。但我相信，如果你给我一个不那么肮脏的建议，我可以学到更多关于优秀编程的知识

那么，您可以在您的类型中实现接口。它由Java中所有类似列表的类实现。当然，它提供了比您可能需要的更多的方法，但是您可以只实现您需要的方法，并在其他方法中抛出一个未实现的异常。

好的，您可以在您的类型中实现接口。它由Java中所有类似列表的类实现。当然，它提供了比您可能需要的更多的方法，但是您可以只实现那些您需要的方法，并在其他方法中抛出一个未实现的异常。

执行接口路径似乎是一个好主意。定义您自己的接口

MyInterface

，并让

MyType

实现它：

class MyType implements MyInterface

现在有个窍门：

LinkedList

不是最终版本！通过扩展JDK类并让它实现您的接口，利用OOP发挥您的优势：

class MyLinkedList extends LinkedList implements MyInterface

---

让我们知道这是否对您有用…

走接口路线似乎是个好主意。定义您自己的接口

MyInterface

，并让

MyType

实现它：

class MyType implements MyInterface

现在有个窍门：

LinkedList

不是最终版本！通过扩展JDK类并让它实现您的接口，利用OOP发挥您的优势：

class MyLinkedList extends LinkedList implements MyInterface

---

让我们知道这是否对您有用…

在Java中，一个字段不能有两种不同的类型；您所能做的最接近的就是拥有一个字段，该字段是一些常见的基类型。所以你有几个选择

使用提供

添加

和

删除

的公共基类型。显然，这是

集合

，它由

链接列表

实现

使用不提供所需方法，但在需要时强制转换对象的公共基类型。在这种情况下，您可以简单地拥有一个类型为

Object

的字段，并且每次您想要使用您的字段时，您必须将其强制转换为实际类型中的任何一种

使用两个字段。这似乎更有意义——拥有两种不同类型的一个变量实际上并不是变量的工作方式

将

LinkedList

和

MyType

包装到具有提供所需方法的公共基类型的类中

例如：

interface WrapperThing<T> {
    void add(T item);
    void remove(T item);
}
class ListWrapperThing<T> implements WrapperThing<T> {
    private List<T> list;
    public ListWrapperThing() {
        list = new LinkedList<T>();
    }
    public void add(T item) {
        list.add(item);
    }
    public void remove(T item) {
        list.remove(item);
    }
}
class MyTypeWrapperThing<T> implements WrapperThing<T> {
    private MyType<T> my;
    public ListWrapperThing() {
        my = new MyType<T>();
    }
    public void add(T item) {
        my.add(item);
    }
    public void remove(T item) {
        my.remove(item);
    }
}

接口包装器{
无效添加（T项）；
消除无效（T项）；
}
类ListWrapperThing实现了WrapperThing{
私人名单；
公共ListWrapperThing（）{
列表=新的LinkedList（）；
}
公共作废新增（T项）{
列表。添加（项目）；
}
公共作废删除（T项）{
列表。删除（项目）；
}
}
类MyTypeWrapperThing实现WrapperThing{
私人MyType my；
公共ListWrapperThing（）{
my=新的MyType（）；
}
公共作废新增（T项）{
我的.添加（项目）；
}
公共作废删除（T项）{
删除（项目）；
}
}

---

然后您可以使用

WrapperThing

变量，就像它是一个变量，可以（在它里面）包含

List

或

MyType

对象一样；您所能做的最接近的就是拥有一个字段，该字段是一些常见的基类型。所以你有几个选择

使用提供

添加

和

删除

的公共基类型。显然，这是

集合

，它由

链接列表

实现

使用不提供所需方法，但在需要时强制转换对象的公共基类型。在这种情况下，您可以简单地拥有一个类型为

Object

的字段，并且每次您想要使用您的字段时，您必须将其强制转换为实际类型中的任何一种

使用两个字段。这似乎更有意义——拥有两种不同类型的一个变量实际上并不是变量的工作方式

将

LinkedList

和

MyType

包装到具有提供所需方法的公共基类型的类中

例如：

interface WrapperThing<T> {
    void add(T item);
    void remove(T item);
}
class ListWrapperThing<T> implements WrapperThing<T> {
    private List<T> list;
    public ListWrapperThing() {
        list = new LinkedList<T>();
    }
    public void add(T item) {
        list.add(item);
    }
    public void remove(T item) {
        list.remove(item);
    }
}
class MyTypeWrapperThing<T> implements WrapperThing<T> {
    private MyType<T> my;
    public ListWrapperThing() {
        my = new MyType<T>();
    }
    public void add(T item) {
        my.add(item);
    }
    public void remove(T item) {
        my.remove(item);
    }
}

接口包装器{
无效添加（T项）；
消除无效（T项）；
}
类ListWrapperThing实现了WrapperThing{
私人名单；
公共ListWrapperThing（）{
列表=新的LinkedList（）；
}
公共作废新增（T项）{
列表。添加（项目）；
}
公共作废删除（T项）{
列表。删除（项目）；
}
}
类MyTypeWrapperThing实现WrapperThing{
私人MyType my；
公共ListWrapperThing（）{
my=新的MyType（）；
}
公共作废新增（T项）{
我的.添加（项目）；
}
公共作废删除（T项）{
删除（项目）；
}
}

然后您可以像使用变量一样使用

WrapperThing

变量