泛型

泛型之间的继承关系

   一、接口继承

/**
*正确的继承
*继承类包括被继承中所有的类型
*/

public interface IStubConsumer<StubType> {
    Class<StubType> getStubType();
}

public interface InvokeAction<Stub,Rsp> {
    Rsp doInvoke(Stub stub);
}

public interface IRemoteInvocation<Stub,Rsp> extends InvokeAction<Stub,Rsp>,IStubConsumer<Stub> {
    Rsp decode(Object rawResponse);

}

 

/**
*正确的继承
*继承类中的泛型比被继承勒种的泛型多,此例子是多个泛型M
*
*/
public interface IStubConsumer<StubType> {
    Class<StubType> getStubType();
}

public interface InvokeAction<Stub,Rsp> {
    Rsp doInvoke(Stub stub);
}

public interface IRemoteInvocation<Stub,Rsp,M> extends InvokeAction<Stub,Rsp>,IStubConsumer<Stub> {
    Rsp decode(Object rawResponse);
}

/**
*错误的继承
*
*继承中的泛型比被继承中的泛型少,此例子是少个泛型Rsp
*
*/

public interface IStubConsumer<StubType> {
    Class<StubType> getStubType();
}

public interface InvokeAction<Stub,Rsp> {
    Rsp doInvoke(Stub stub);
}

public interface IRemoteInvocation<Stub> extends InvokeAction<Stub,Rsp>,IStubConsumer<Stub> {
    Rsp decode(Object rawResponse);
}

/**
*错误的继承
*被继承中泛型类型个数,要和本身的泛型数量相同,
*此例子被继承的接口比InvokeAction比原有的泛型少了一个
*泛型Rsp
*/

public interface IStubConsumer<StubType> {
    Class<StubType> getStubType();
}

public interface InvokeAction<Stub,Rsp> {
    Rsp doInvoke(Stub stub);
}

/*
*错误
*被继承的接口InvokeAction比原有的接口少了一个泛型
*Rsp
*/
public interface IRemoteInvocation<Stub,Rsp> extends InvokeAction<Stub>,IStubConsumer<Stub> {
    Rsp decode(Object rawResponse);
}

 

/**
*正确
*被继承中的泛型,泛型类型可以一个都不用,表示具体的队形
*Object
*
*/

public interface IStubConsumer<StubType> {
    Class<StubType> getStubType();
}

public interface InvokeAction<Stub,Rsp> {
    Rsp doInvoke(Stub stub);
}


/**
*正确
*被继承的接口InvokeAction一个泛型都没有添加,表示被继承的
*接口的泛型被具体的对象所代替
*
*/
public interface IRemoteInvocation<Stub,Rsp> extends InvokeAction,IStubConsumer<Stub> {
    Rsp decode(Object rawResponse);
}

 

/**
*错误
*
*被继承的接口中的泛型不能被缩小
*/

public interface InvokeAction<Stub,Rsp> {
    Rsp doInvoke(Stub stub);
}


/**
*被继承的接口InvokeAction中的泛型Rsp 被缩小成了User的子类
*
*/
public interface IRemoteInvocation<Stub,Rsp> extends InvokeAction<Stub ,Rsp extends User>{


}

/**
*正确
*
*继承类中的泛型被缩小
*/
public interface InvokeAction<Stub,Rsp> {
    Rsp doInvoke(Stub stub);
}


/**
*继承接口IRemoteInvocation中的泛型范围被缩小,Rsp被缩小成了Usr的*子类
*/
public interface IRemoteInvocation<Stub,Rsp extends User> extends InvokeAction<Stub ,Rsp >{


}

/**
*正确
*被继承几口中的泛型被具体的对象代替
*/

public interface InvokeAction<Stub,Rsp> {
    Rsp doInvoke(Stub stub);
}


/**
*被继承接口中的泛型Rsp被具体的对象User 代替
*/

public interface IRemoteInvocation<Stub> extends InvokeAction<Stub ,User >{


}

/**
*错误
*
*继承接口中的类不能被具体的对象代替
*/

public interface InvokeAction<Stub,Rsp> {
    Rsp doInvoke(Stub stub);
}

/**
*错误
*
*继承接口IRemoteInvocation中的泛型Rsp被具体的对象User替代
*/
public interface IRemoteInvocation<Stub,User> extends InvokeAction<Stub ,Rsp >{


}

 

 

总结:接口继承的时候,继承类中泛型不能少于被继承中的泛型,被继承的泛型要么和本身的泛型一样,要么一个泛型都不用,没有一个泛型表示是被具体的对象Object

所代替,类的泛型继承是和接口是相同的,即

　　1)继承的类的泛型要包含被继承类的所有泛型,即继承类的泛型数量大于等于被继承类的泛型

　　2)被继承类的泛型要和本身的泛型保持一致

　　3)被继承类可以不用写任何泛型,表示泛型被具体的对象类型Object所替代

       4)被继承的类中的泛型范围不能通过继承关系被缩小,但是继承类中的泛型范围可以通过继承关系被缩小

       5)被继承的类中的泛型可以被具体的对象所替代,但是继承类中的泛型不能被具体的对象所代替

二、类继承

　

/**
*正确的继承
*
*继承类中的泛型和被继承类中的泛型相同
*/
public interface InvokeAction<Stub,Rsp> {
    Rsp doInvoke(Stub stub);
}

public abstract class AbstractInvocation<Stub,Rsp> implements InvokeAction<Stub,Rsp> {
    public String getName(){
        return "zs";
    }
}

 

/**
*正确的继承
*
*继承中的泛型比被继承中的泛型多了一个类型M
*/
public interface InvokeAction<Stub,Rsp> {
    Rsp doInvoke(Stub stub);
}

public abstract class AbstractInvocation<Stub,Rsp,M> implements InvokeAction<Stub,Rsp> {
    public String getName(){
        return "zs";
    }
}

 

/**
*错误的继承
*
*继承中的泛型比被继承中的泛型少,此例少了一个泛型Rsp
*/

public interface InvokeAction<Stub,Rsp> {
    Rsp doInvoke(Stub stub);
}

public abstract class AbstractInvocation<Stub> implements InvokeAction<Stub,Rsp> {
    public String getName(){
        return "zs";
    }
}

/*
*正确
*被继承的接口InvokeAction没有一个泛型,表是泛型是具体的对象Object
*/
public interface InvokeAction<Stub,Rsp> {
    Rsp doInvoke(Stub stub);
}


/**
*InvokeAction没有泛型,表示此接口中的泛型被是具体的对象Object
*/
public interface IRemoteInvocation<Stub,Rsp> extends InvokeAction,IStubConsumer<Stub> {
    Rsp decode(Object rawResponse);
}

 

总结:以上类的继承是和接口的继承是相同的,关于泛型类和类的继承,也是具有和接口之间泛型的继承关系是相同的,即

　　1)继承的类的泛型要包含被继承类的所有泛型,即继承类的泛型数量大于等于被继承类的泛型

　　2)被继承类的泛型要和本身的泛型保持一致

　　3)被继承类可以不用写任何泛型,表示泛型被具体的对象类型Object所替代

 

       

/**
*正确
*
*被继承类中的泛型被具体的对象所代替
*/

public class User {
    private String id;
    private String name;
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

public interface InvokeAction<Stub,Rsp> {
    Rsp doInvoke(Stub stub);
}



/**
*此处的泛型被具体的对象User所代替
*/
public class Invocation<Stub> implements InvokeAction<Stub,User> {
    @Override
    public User doInvoke(Stub stub) {
        return null;
    }
}

/**
*错误
*
*被继承类中的泛型范围不能被缩小
*/

public class User {
    private String id;
    private String name;
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

public interface InvokeAction<Stub,Rsp> {
    Rsp doInvoke(Stub stub);
}

/**
*InvokeAction中的泛型Rsp范围被缩小成了User的子类
*/
public class Invocation<Stub> implements InvokeAction<Stub,Rsp extends User> {
    @Override
    public Rsp doInvoke(Stub stub) {
        return null;
    }
}

/**
*正确
*
*继承类中的泛型被缩小
*/
public class User {
    private String id;
    private String name;
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

public interface InvokeAction<Stub,Rsp> {
    Rsp doInvoke(Stub stub);
}


/*
*正确
*
*Invocation中的泛型Rsp被缩小成User的子类
*/
public class Invocation<Stub,Rsp extends User> implements InvokeAction<Stub,Rsp> {

    @Override
    public Rsp doInvoke(Stub stub) {
        return null;
    }
}

/**
*错误
*
*继承类中的泛型不能被具体的对象代替,原因:因为被具体的对象替代了后
*继承中的泛型会比被继承的中的泛型少了一个被替代的泛型
*/

public class User {
    private String id;
    private String name;
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

public interface InvokeAction<Stub,Rsp> {
    Rsp doInvoke(Stub stub);
}


/**
*错误
*
*Invocation中的泛型Stub被具体的对象User替代,次数少了一个
*泛型Stub
*/
public class Invocation<User,Rsp> implements InvokeAction<Stub,Rsp> {


}

总结:

   1)被继承的类中的泛型范围不能通过继承关系被缩小,但是继承类中的泛型范围可以通过继承关系被缩小

   2)被继承的类中的泛型可以被具体的对象所替代,但是继承类中的泛型不能被具体的对象所代替

 

总之:无论是接口中泛型继承还是类中的泛型继承都具有一下特点

　   1)继承的类的泛型要包含被继承类的所有泛型,即继承类的泛型数量大于等于被继承类的泛型

　　2)被继承类的泛型要和本身的泛型保持一致

　　3)被继承类可以不用写任何泛型,表示泛型被具体的对象类型Object所替代

       4)被继承的类中的泛型范围不能通过继承关系被缩小,但是继承类中的泛型范围可以通过继承关系被缩小

       5)被继承的类中的泛型可以被具体的对象所替代,但是继承类中的泛型不能被具体的对象所代替