Java 泛型扩展而不扩展-如何做

我做了一些事情：

class Tuple1<T1, T2> {
    private T1 a;
    private T2 b;

    public Tuple1(T1 a, T2 b) {
        this.a = a;
        this.b = b;
    }

    public T1 getA() {
        return a;
    }

    public T2 getB() {
        return b;
    }

    @Override
    public String toString() {
        return "[" + a.toString() + ", " + b.toString() + "]";
    }
}

类Tuple1{
私人T1 a；
私人t2b；
公共元组1（T1 a，T2 b）{
这个a=a；
这个.b=b；
}
公共T1 getA（）{
返回a；
}
公共服务{
返回b；
}
@凌驾
公共字符串toString（）{
返回“[”+a.toString（）+”，“+b.toString（）+””；
}
}

---

现在我必须做Tuple2（a，b+c字段）和Tuple3（a，b，c+d字段），它们的功能与Tuple1相同，但没有

扩展
和代码冗余。
您可以创建多个构造函数，它们可以做您想做的事情：

例如：

private T1 a;
private T2 b;
//create a new attribute
private T2 c;

//constructor with two attributes
public Tuple1(T1 a, T2 b) {
    this.a = a;
    this.b = b;
}

//constructor with three attributes
public Tuple1(T1 a, T2 b, T2 c) {
    this.a = a;
    this.b = b;
    this.c = c;
}

//getters and setters of your attributes

因此，如果要使用两个属性：

Tuple1 t1 = new Tuple1(a, b);

Tuple1 t2 = new Tuple1(a, b, c);

因此，如果要使用三个属性：

Tuple1 t1 = new Tuple1(a, b);

Tuple1 t2 = new Tuple1(a, b, c);

您可以在本Oracle教程中了解更多信息：

前后

希望这能对您有所帮助。
您可以制作
Tuple2
和类似的Tuple3。您可以将
Tuple1
存储为Tuple2中与
t3c
一起的私有字段，并实现所有必需的方法，其中一些方法只是将其调用委托给适当的Tuple1方法。它可能看起来是多余的，但是你确实需要有一个方法来声明它，所以没有办法避免它。
 < P>你可以考虑以下的解决方案：

class Tuple<T1, T2>
{
    private T1 a;
    private T2 b;

    public Tuple1(T1 a, T2 b)
    {
        this.a = a;
        this.b = b;
    }

    public T1 getA() { return a; }

    public T2 getB() { return b; }

    @Override
    public String toString()
    {
        return "[" + a.toString() + ", " + b.toString() + "]";
    }
}

class Tuple2<T1, T2, T3> 
{
    private Tuple1<T1, T2> tuple;
    private T3 c;

    public Tuple2(T1 a, T2 b, T3 c)
    {
        this.tuple = new Tuple1<T1, T2>(a, b);
        this.c = c;
    }

    public T1 getA() { return tuple.getA(); }

    public T2 getB() { return tuple.getB(); }

    public T3 getC() { return c; }

    @Override
    public String toString()
    {
        return "[" + getA().toString() + ", " + getB().toString() + ", " + c.toString() + "]";
    }
}

class Tuple3<T1, T2, T3, T4> 
{
    private Tuple2<T1, T2, T3> tuple;
    private T4 d;

    public Tuple3(T1 a, T2 b, T3 c, T4 d)
    {
        this.tuple = new Tuple2<T1, T2, T3>(a, b, c);
        this.d = d;
    }

    public T1 getA() { return tuple.getA(); }

    public T2 getB() { return tuple.getB(); }

    public T3 getC() { return tuple.getC(); }

    public T4 getD() { return d; }

    @Override
    public String toString()
    {
        return "[" + getA().toString() + ", " + getB().toString() + ", " + getC().toString() + ", " + d.toString() + "]";
    }
}

类元组
{
私人T1 a；
私人t2b；
公共元组1（T1 a，T2 b）
{
这个a=a；
这个.b=b；
}
公共T1 getA（）{return a；}
public T2 getB（）{return b；}
@凌驾
公共字符串toString（）
{
返回“[”+a.toString（）+”，“+b.toString（）+””；
}
}
类Tuple2
{
私有元组1元组；
私人T3C；
公共元组2（T1 a、T2 b、T3 c）
{
this.tuple=新的Tuple1（a，b）；
这个.c=c；
}
公共T1 getA（）{return tuple.getA（）；}
public T2 getB（）{return tuple.getB（）；}
public T3 getC（）{return c；}
@凌驾
公共字符串toString（）
{
返回“[”+getA（）.toString（）+”，“+getB（）.toString（）+”，“+c.toString（）+”；
}
}
类Tuple3
{
私有元组2元组；
私人T4 d；
公共元组3（T1 a、T2 b、T3 c、T4 d）
{
this.tuple=新的Tuple2（a，b，c）；
这个。d=d；
}
公共T1 getA（）{return tuple.getA（）；}
public T2 getB（）{return tuple.getB（）；}
public T3 getC（）{return tuple.getC（）；}
public T4 getD（）{return d；}
@凌驾
公共字符串toString（）
{
返回“[”+getA（）.toString（）+”，“+getB（）.toString（）+”，“+getC（）.toString（）+”，“+d.toString（）+”；
}
}
有趣的家庭作业。还有什么办法可以解决吗？你目前的用法也没有扩展。你说的代码冗余是什么意思？在Tuple2的构造中重用Tuple1？你可以看一看jOOλ库的源代码，它实现了一些非常类似于你要做的事情：谢谢，但是Tuple2和Tuple3必须是一个类。@hqid，是的，然后你可以像我以前一样用不同的构造函数创建类