Create a generic method with generic signature-CodePudding

i have some redundant code that i would like to remove, my goal would be to create a method of this kind:

private GenericClass myMethod(GenericClass genericClass){
    genericClass.getTipe(); //tipe1 or tipe2
    genericClass.setValue("foo");
    genericClass.setValue2("foo");
    //some logic
    return genericClass;

}

Where this method can pass two similar classes but which differ in the type of an attribute

public class Class1{
   private Tipe1 tipe1;
   private String value; 
   private String value2;
   //Constructor,Getter and Setter
}

public class Class2{
   private Tipe2 tipe2;
   private String value; 
   private String value2;
   //Constructor,Getter and Setter
}

What I would like to do is call the method

someServiceIml.myMethod ("Foo")

passing either an object of type Class1 or Class2 according to my needs, the business logic behind myMethod is practically the same.

This method i wish it was in the same implementation of a certain service, could you give me some solution?

CodePudding user response：

public class MyClass {
    public static void main(String args[]) {
      
        Class1 c1 = new Class1();
        
        Class2 c2 = new Class2();

        GenericClass gc = myMethod(c1);
        
        System.out.println(gc);
    }
    
    private static GenericClass myMethod(GenericClass genericClass){
        genericClass.getTipe(); //tipe1 or tipe2
        genericClass.setValue("foo");
        genericClass.setValue2("foo");
        //some logic
        return genericClass;
    }
}

class Class1 extends GenericClass<Tipe1>{

}

class Class2 extends GenericClass<Tipe2>{

}

class Tipe1 {
    
}
class Tipe2 {
    
}

class GenericClass<T> implements Tipe<T> {
    private String value;
    private String value2;
    private T t;
    
    public T getTipe() {
        return t;
    }
    
    void setValue(String s) {
        value = s;
    }
    void setValue2(String s) {
        value2 = s;
    }
}

interface Tipe<T> {
    public T getTipe();
}

or you can cast to parent class like:

GenericClass gc = new Class2();

CodePudding user response：

Create a generic abstract type; either a super class or an interface:

public interface GenericClass<T> {
    public T getTipe();
    public void setValue(String s);
    public void setValue2(String s);
}

Have your implementation classes implement it:

public class Class1 implements GenericClass<Tipe1> {
    // leave implementation as is
}

public class Class2 implements GenericClass<Tipe2> {
    // leave implementation as is
}

And type your method:

private <T> GenericClass<T> myMethod(GenericClass<T> genericClass){
    T tipe = genericClass.getTipe();
    genericClass.setValue("foo");
    genericClass.setValue2("foo");
    // some logic
    return genericClass;
}

If Tipe1 and Tipe2 share a common type, you can type them too:

public interface GenericClass<T extends SomeTipe> {