Java 一种在没有警告的情况下创建匹配的泛型类对的方法？

我想知道当我使用相互引用的泛型类时，是否有办法消除rawtypes警告：

public class DummyDeleteMe {
abstract class RightSide<L extends LeftSide>{ //Can I use a type parameter here?
    L getLeftSide() {return _mate;}
    void setLeftSide(L mate) {_mate = mate;}
    L _mate;
    void connectToMate(){
        getLeftSide().setRightSide(this);//warning: 
        /** [unchecked] unchecked call to setRightSide(R) as a member of the raw type DummyDeleteMe.LeftSide
         where R is a type-variable:  * **/
    }
}

abstract class LeftSide<R extends RightSide>{// And here?
    R getRightSide(){return _mate;}
    void setRightSide(R mate) {_mate = mate;}
    R _mate;
}
 class RightSideSub extends RightSide<LeftSideSub>{
    void connectToMate(){
        getLeftSide().setRightSide(this);//No warning
    }
 }
  class LeftSideSub extends LeftSide<RightSideSub>{}
}

---

但是这会导致

R

变量和返回

R

的方法中出现其他类型的不匹配错误。我知道这可能不是您想要的，但它可能会解决您的问题。仅基于代码示例中显示的内容，根本不需要泛型。这使问题过于复杂化了。也就是说，如果您的示例非常符合您的需要

假设是这样的话，像这样的东西怎么样

public interface Half{
    public Half getOtherHalf();
}

public class RightSide implements Half{
    private LeftSide leftSide;

    public void setLeftSide(LeftSide leftSide){
        this.leftSide = leftSide;
    }

    @Override
    public LeftSide getOtherHalf() {
        return leftSide;
    }
}

public class LeftSide implements Half{
    private RightSide rightSide;

    public void setRightSide(RightSide rightSide){
        this.rightSide = rightSide;
    }

    @Override
    public RightSide getOtherHalf(){
        return rightSide;   
    }
}

---

我知道这可能不是你想要的，但它可以解决你的问题。仅基于代码示例中显示的内容，根本不需要泛型。这使问题过于复杂化了。也就是说，如果您的示例非常符合您的需要

假设是这样的话，像这样的东西怎么样

public interface Half{
    public Half getOtherHalf();
}

public class RightSide implements Half{
    private LeftSide leftSide;

    public void setLeftSide(LeftSide leftSide){
        this.leftSide = leftSide;
    }

    @Override
    public LeftSide getOtherHalf() {
        return leftSide;
    }
}

public class LeftSide implements Half{
    private RightSide rightSide;

    public void setRightSide(RightSide rightSide){
        this.rightSide = rightSide;
    }

    @Override
    public RightSide getOtherHalf(){
        return rightSide;   
    }
}

---

这里有一个解决方案。我已经删除了对“左侧”的

L

和对“右侧”的

R

的引用，并将其替换为对“这一侧”的

T

，对“另一侧”的

O

---

这里有一个解决方案。我已经删除了对“左侧”的

L

和对“右侧”的

R

的引用，并将其替换为对“这一侧”的

T

，对“另一侧”的

O

public class Solution1 {
    abstract static class Side<T extends Side<T, O>, O extends Side<O, T>> {
        Side<O, T> _mate = null;

        Side<O, T> getOtherSide() {
            return _mate;
        }

        void setOtherSide(Side<O, T> mate) {
            _mate = mate;
        }

        void connectToMate() {
            getOtherSide().setOtherSide(this);
        }
    }

    //You concrete implementations can replace This and Other
    //with Right and Left as you see fit.

    static class RightSideSub extends Side<RightSideSub, LeftSideSub> {
    }

    static class LeftSideSub extends Side<LeftSideSub, RightSideSub> {
    }
}

class OtherSolution{
    abstract static class Side<O>{
        O _mate = null;
        void setOtherSide(O mate){
            _mate = mate;
        }
    }

    static class RightSideSub extends Side<LeftSideSub> {
    }

    static class LeftSideSub extends Side<RightSideSub> {
    }

    public static void main(String[] args) {
        RightSideSub rs = new RightSideSub();
        LeftSideSub ls = new LeftSideSub();
        //do the connectToMate() operation externally like this:
        rs.setOtherSide(ls);
        ls.setOtherSide(rs);
    }
}