Is there a way in Java generics to return different kinds of datatype?-CodePudding

So i'm trying to develop a fluent interface for some DSL in Java and am running into a problem. The interface consists of builder pattern classes that each construct part of the DSL. The problem is that a specific builder sometimes needs to transfer control to a different builder which at some point returns to the 'parent' builder. For example, there is a 'SequenceBuilder' that creates a list of statements but it need sometimes transfer control to an 'IfBuilder' that is used to create an 'if' statement. When the IfBuilder is finished, it needs to return to the SequenceBuilder. Now there are some builders that are not always called by the same type of other builder and therefore need to be able to return builders of a different datatype. The example program below demonstrates this:

package com.example.fluent;

public class Test {

    public class Type1 {
        public Type1 test1() {
            System.out.println("test1");
            return this;
        }
        public Type3 gotype3() {
            System.out.println("gotype3");
            return new Type3<Type1>(this);
        }
        public void endtype1() {
            System.out.println("endtype1");
        }
    }

    public class Type2 {
        public Type2 test2() {
            System.out.println("test2");
            return this;
        }
        public Type3 gotype3() {
            System.out.println("gotype3");
            return new Type3<Type2>(this);
        }
        public void endtype2() {
            System.out.println("endtype2");
        }
    }

    public class Type3<T> {
        private T parent;
        public Type3(T parent) {
            this.parent = parent;
        }
        public Type3 test3() {
            System.out.println("test3");
            return this;
        }
        public T endtype3() {
            System.out.println("endtype3");
            return parent;
        }
    }

    public static void main(String[] args) {
        new Test().run();
    }

    private void run() {
        new Type1()
            .test1()
            .gotype3()
                .test3()
                .endtype3()
            .test1()
            .endtype1();
    }
}

You can see in the .run() method that i start by creating a new instance of the Type1 class, which follows the builder pattern. At some point i'm calling the .goType3() method which transfers control to the Type3 builder. Because it has to return control at some point to Type1 again, a reference to that builder is passed via constructor to Type3. When it's time to return to Type1, the method .endtype3() is called. And here lies the problem. I'm using generics to (try) to return the datatype of Type1 but instead it's converted to an Object type. That datatype obviously does not have the methods that Type1 has and therefore the pattern is broken.

Question: is there some other way to return the proper datatype to the parent builder?

CodePudding user response：

You're not using generics as much as you want to. You're using return type Type3. You need to use Type3<Type1>, Type3<Type2> and Type3<T> instead.

CodePudding user response：

Thanks to Rob Spoor i got my code finally working, though i didn't understand it at first. The solution lies in changing the code in the following ways:

package com.example.fluent;

public class Test {

    public class Type1 {
        public Type1 test1() {
            System.out.println("test1");
            return this;
        }
        public Type3<Type1> gotype3() {
            System.out.println("gotype3");
            return new Type3<Type1>(this);
        }
        public void endtype1() {
            System.out.println("endtype1");
        }
    }

    public class Type2 {
        public Type2 test2() {
            System.out.println("test2");
            return this;
        }
        public Type3<Type2> gotype3() {
            System.out.println("gotype3");
            return new Type3<Type2>(this);
        }
        public void endtype2() {
            System.out.println("endtype2");
        }
    }

    public class Type3<T> {
        private T parent;
        public Type3(T parent) {
            this.parent = parent;
        }
        public Type3<T> test3() {
            System.out.println("test3");
            return this;
        }
        public T endtype3() {
            System.out.println("endtype3");
            return parent;
        }
    }

    public static void main(String[] args) {
        new Test().run();
    }

    private void run() {
//        new Type1().test1().test1().endtype1();
        new Type1().test1().gotype3().test3().endtype3().test1().endtype1();
//        new Type2().test2().gotype3().test3().endtype3().test2().endtype2();
    }
}

See the changes in the return types of the .gotype3() methods in the Type1 and Type2 classes, as well as the return type of the .test3() method. Now everything is working fine.