class have two constructors

Question

My class has two constructors

class test()

    // declare
    par1 as object, par2 as  object , par3 as object

    // constructors
    public test(par1, par2) {,,,,}
    public test(par1, par2, par3) {,,,,,}

    // Methods 
     fct1() 
     {
          '' do something with par1 and par2
     }


     fct2(){

           if(par3 is null) 
             throw exception ('be sure to use the right constructor ) 
           else
           '' do something with par1 and par2
             and par3
     }

my question :

is it OK to have two constructors like that :

because if some one need to use fct2 he should use constructor number 2 (with 3 parameters) else it is going to throw an exception

is it OK or is there any other better solution

ps: this class is implemented every where if i change first constructor i need to change every place where the class is called

thank you .

There may be better approaches (e.g. base class with two parms + fct1 and a *subclass* with extra parameter and fct2) but it's difficult to tell when you've made the question too *abstract* for us to know what you're really doing. — Damien_The_Unbeliever, Jul 12 '18 at 07:52
It is Ok, and it's not Ok. It all depends on what you want as a behaviour. — Paul Karam, Jul 12 '18 at 07:52
Syntactically it´s pure fine and a constructor - as every method also - can be overloaded by arbitrary arguments. If that is what you really want, is another issue. — MakePeaceGreatAgain, Jul 12 '18 at 07:54
Possible duplicate of [Calling constructor from other constructor in same class](https://stackoverflow.com/questions/829870/calling-constructor-from-other-constructor-in-same-class) — Drag and Drop, Jul 12 '18 at 07:55

score 2 · Answer 1 · answered Jul 12 '18 at 07:54

So you have a class with two methods, and the second method adds functionality to the first. Sounds like an ideal candidate for inheritance:

public class FirstImplementation
{
    public FirstImplementation(param1, param2)
    {
    }

    public virtual Bar Foo()
    {
        // do something with param1, param2
    }
}

Then inherit it to adapt its behavior:

public class SecondImplementation : FirstImplementation
{
    public SecondImplementation(param1, param2, param3)
        : base(param1, param2)
    {
    }

    public override Bar Foo()
    {
        // do something with param1, param2 and param3, perhaps by calling base.Foo().
    }
}

Because you don't want a class that contains the same code twice with slight alterations, that requires the caller to know which constructor to call prior to calling one of its methods, or that throws an InvalidOperationException when the wrong constructor was called. That's unusable and unmaintainable.

class have two constructors

1 Answers1