Перегруженный конструктор вызывает другой конструктор, но не как первый оператор

Question

У меня возникли проблемы с использованием нескольких конструкторов в java.

то, что я хочу сделать что-то вроде этого:

public class MyClass { 

// first constructor 
public MyClass(arg1, arg2, arg3) { 
    // do some construction 
} 

// second constructor 
public MyClass(arg1) { 
     // do some stuff to calculate arg2 and arg3 
     this(arg1, arg2, arg3); 
    } 
} 

, но я не могу, так как второй конструктор не может вызвать другой конструктор, если только он не является первой линией.

Какое общее решение для такой ситуации? Я не могу вычислить arg2 и arg3 «в строке». Я подумал, может быть, создать метод вспомогательного строительства, который будет выполнять фактическую конструкцию, но я не уверен, что это так «хорошо» ...

EDIT: Использование вспомогательного метода также проблематично, поскольку некоторые из моих полей являются окончательными, и я не могу установить их с помощью вспомогательного метода.

Answer 1

Как правило, используйте другой распространенный метод - «вспомогательный элемент конструкции», как вы предложили.

public class MyClass { 

    // first constructor 
    public MyClass(arg1, arg2, arg3) { 
     init(arg1, arg2, arg3); 
    } 

    // second constructor 
    public MyClass(int arg1) { 
     // do some stuff to calculate arg2 and arg3 
     init(arg1, arg2, arg3); 
    } 

    private init(int arg1, int arg2, int arg3) { 
     // do some construction 
    } 
} 

Альтернативы является подходом заводского стиля, в котором у вас есть MyClassFactory, который дает вам MyClass экземпляров, и MyClass имеет только один конструктор:

public class MyClass { 

    // constructor 
    public MyClass(arg1, arg2, arg3) { 
     // do some construction 
    } 
} 

public class MyClassFactory { 

    public static MyClass MakeMyClass(arg1, arg2, arg3) { 
     return new MyClass(arg1, arg2, arg3); 
    } 

    public static MyClass MakeMyClass(arg1) { 
     // do some stuff to calculate arg2 and arg3 
     return new MyClass(arg1, arg2, arg3); 
    } 
} 

Я определенно предпочитаю первый вариант.

Answer 2

Следующее возможное решение: Factory method. Эти статические методы могут быть перегружены и после расчета они могут вызвать частный/защищенный конструктор

public class MyClass { 

    private MyClass(arg1, arg2, arg3) { 
     // do sth 
    } 

    public static MyClass getInstance(arg1) { 
     // calculate arg2,3 
     return new MyClass(arg1, arg2, arg3); 
    } 

    public static MyClass getInstance(arg1, arg2, arg3) { 
     return new MyClass(arg1, arg2, arg3); 
    } 
} 

EDIT: Этот метод также идеально подходит, если у вас есть конечные поля

Answer 3

Вы можете переместить код MyClass(arg1, arg2, arg3) в вспомогательный метод (назовите его Init или что-то еще), а затем вызовите этот метод в обоих конструкторах.

Answer 4

Вы можете создать factory method, который вызывает конструктор:

public class MyClass { 

    // first constructor 
    public MyClass(arg1, arg2, arg3) { 
    // do some construction 

    } 

    // second constructor as factory method 
    public static createMyClassAndDoFunkyStuff(int arg1) { 
     // do some stuff to calculate arg2 and arg3 
     return new MyClass(arg1, arg2, arg3); 
    } 

} 

Answer 5

хелперные и фабричные варианты очень хороши.

Существует еще один:

public MyClass(int arg1) { 
    this(arg1, calculateArg2(), calculateArg3()); 
} 

private static int calculateArg2() {..} 
private static int calculateArg3() {..} 

Answer 6

Хотя я предпочитаю вариант фабричный метод указывает несколько других ответов, я хотел бы предложить другой вариант: Вы можете использовать статические методы, чтобы сделать расчет ваших других параметров :

public class MyClass { 
    public MyClass(int arg1, int arg2, int arg3) { 
     // do some construction 
    } 

    public MyClass(int arg1) { 
     //call to this() must be the first one 
     this(arg1, calculateArg2(arg1), calculateArg3()); 
     //you can do other stuff here 
    } 

    private static int calculateArg2(int arg1) { 
     //calc arg2 here 
    } 

    private static int calculateArg3() { 
     //calc arg3 here 
    } 
} 

Answer 7

Другой способ заключается в следующем:

public class MyClass { 

    // first constructor 
    public MyClass(arg1, arg2, arg3) { 
    // do some construction 
    doSomeStuffToArg3Arg3(arg2, arg3) 
    } 

    // second constructor 
    public MyClass(int arg1) { 
     this(arg1, arg2, arg3); 
    } 

    private void doSomeStuffToArg3Arg3(int arg2, int arg3) { 
    // do some stuff to calculate arg2 and arg3 
    } 
} 

Answer 8

Как альтернативой указанным ответам, самый простой способ - реорганизовать вычисление аргумента на конструктор 3 аргументов;

public class MyClass { 

    // first constructor 
    public MyClass(arg1, arg2, arg3) { 
     if (null == arg2) { 
      // calculate arg2 
     } 
     if (null == arg3) { 
      // calculate arg3 
     } 
     // do some construction 
    } 

    // second constructor 
    public MyClass(arg1) { 
     this(arg1, null, null); 
    } 
} 

Answer 9

Использовать значения маркеров для 'отсутствует'

public class MyClass { 
public MyClass(arg1, arg2, arg3) { 
    // do some stuff to calculate arg2 and arg3 if they are the missing values 
    // do some construction 
} 
public MyClass(arg1) { 
    this(arg1, null, null); 
} 
} 

Для достижения наилучших результатов, сделать 'общий' конструктор protected или private.