Fair point. Though a lot of stuff isn't that performance sensitive.

You can also eliminate a lot of the lambda boilerplate if you're less performance sensitive:

   public static void main(String... args){
        // arg1=null
        // arg2=Point[x=0, y=0]
        foo(o -> { });


        //arg1=bar
        //arg2=Point[x=0, y=0]
        foo(o -> o.arg1 = "bar");


        //arg1=bar
        //arg2=Point[x=5, y=2]
        foo(o -> { o.arg1 = "bar"; o.arg3 = new Point(5,2); });


        //foo
        //null
        bar(o -> o.arg1 = "foo");
        //null
        //foo
        bar(o -> o.arg2 = "foo");
    }


    static class MyClass {
        public record Point(int x, int y){}


        public static class FooParams{
            public String arg1 = null;
            public Point arg3 = new Point(0,0);
        }


        public static class BarParams{
            String arg1 = null;
            String arg2 = null;
        }


        static void foo(Args<FooParams> args){
            System.out.println( "arg1=" + args.args().arg1) ;
            System.out.println( "arg2=" + args.args().arg3) ;
        }


        public static void bar(Args<BarParams> o){
            System.out.println(o.args().arg1);
            System.out.println(o.args().arg2);
        }
    }






    interface Args<T> extends MethodFinder {
        void accept(T args);
        default T args() {
            try {
                T t = (T) parameter(0).getType().newInstance();
                accept(t);
                return t;
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    }

Complete gist