构造函数重载的工作原理

Question

如果我无法修改Factory.create 方法（只能修改Task 和SubType 类），如何使Factory.create 调用Task.<init>(SubType) 构造函数？

public class Test {

    public static void main(String[] args) {
        Factory.create(new SubType());
        // OUTPUT:
        // task instanceof SubType: true
        // callable  (PROBLEM: I want SubType constructor to be invoked)
    }

    public static class SubType implements Callable {
        @Override
        public Object call() throws Exception {
            return null;
        }
    }

    public static class Task {
        private Callable callable;
        private SubType subType;

        public Task(SubType subType) {
            System.out.println("Subtype");
            this.subType = subType;
        }
        public Task(Callable callable) {
            System.out.println("callable");
            this.callable = callable;
        }
    }

    public static class Factory {

        // If change method argument type to SubType it will invoke 
        // Task.<init>(SubType) constructor, but I can't modify it
        public static Task create(Callable task) {
            System.out.println("task instanceof SubType: " + (task instanceof SubType));
            return new Task(task);
        }
    }
}

Answer 1

在Task类上创建一个公共工厂静态方法，并使构造函数私有，或者包私有

public static class Task {
    private Callable callable;
    private SubType subType;

    private Task(SubType subType) {
        System.out.println("Subtype");
        this.subType = subType;
    }
    private Task(Callable callable) {
        System.out.println("callable");
        this.callable = callable;
    }

    public static Task create ( final Callable callable )
    {
       if ( callable instance of SubTask )
       {
         return new Task( (SubType) callable );
       }

       return new Task( callable );

    }
}

public static class Factory {

    // Note that we are now calling Task's factory method
    public static Task create(Callable task) {
        System.out.println("task instanceof SubType: " + (task instanceof SubType));
        return Task.create(task);
    }
}

Answer 2

根据参数的声明类型，在编译时选择调用哪个重载方法或构造函数。因此，即使task 的实际具体 类型是SubType，它的声明 类型是Callable，而第二个构造函数以一个Callable 作为参数，将始终被调用。

因此，如果您希望在使用 SubType 构造 Task 时发生不同的事情，那么您应该在 Task 构造函数中测试 Callable 的类型：

 public static class Task {
    private Callable callable;
    private SubType subType;

    public Task(Callable callable) {
        if (callable instanceof SubTask) {
            System.out.println("Subtype");
            this.subType = subType;
        }
        else {
            System.out.println("callable");
            this.callable = callable;
        }
    }
}