blocks|key|1808042|text|你不能在PHP中重载任何方法。如果您希望在传递几种不同的参数组合时能够实例化PHP对象，请使用带有私有构造函数的工厂模式。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1808043|例如：|1808044|public+MyClass+{
++++private+function+__construct()+{
++++...
++++}

++++public+static+function+makeNewWithParameterA($paramA)+{
++++++++$obj+=+new+MyClass();+
++++++++//+other+initialization
++++++++return+$obj;
++++}

++++public+static+function+makeNewWithParametersBandC($paramB,+$paramC)+{
++++++++$obj+=+new+MyClass();+
++++++++//+other+initialization
++++++++return+$obj;
++++}
}

$myObject+=+MyClass::makeNewWithParameterA("foo");
$anotherObject+=+MyClass::makeNewWithParametersBandC("bar",+3);|code-block|syntax|javascript|1808045|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

You can't overload ANY method in PHP. If you want to be able to instantiate a PHP object while passing several different combinations of parameters, use the factory pattern with a private constructor. 

For example:

<pre><code>public MyClass {
 private function __construct() {
 ...
 }

 public static function makeNewWithParameterA($paramA) {
 $obj = new MyClass(); 
 // other initialization
 return $obj;
 }

 public static function makeNewWithParametersBandC($paramB, $paramC) {
 $obj = new MyClass(); 
 // other initialization
 return $obj;
 }
}

$myObject = MyClass::makeNewWithParameterA("foo");
$anotherObject = MyClass::makeNewWithParametersBandC("bar", 3);
</code></pre>

blocks|key|1807719|text|您可以使用variable+arguments来产生相同的效果。如果没有强类型，在给定默认参数和所有其他“变通方法”的情况下，添加没有多大意义。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1807720|entityMap|0|LINK|mutability|MUTABLE|url|http://php.net/manual/en/function.func-get-arg.php^0|5|I|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

You can use <a href="http://php.net/manual/en/function.func-get-arg.php" rel="noreferrer">variable arguments</a> to produce the same effect. Without strong typing, it doesn't make much sense to add, given default arguments and all of the other "work arounds."

blocks|key|1808340|text|为了完整起见，我建议使用Fluent+Interfaces。其想法是，通过将return+$this;添加到方法的末尾，您可以将调用链接在一起。因此，不是|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1808341|$car1+=+new+Car('blue',+'RWD');
$car2+=+new+Car('Ford',+'300hp');|code-block|syntax|javascript|1808342|(这根本不会起作用)，你可以这样做：|1808343|$car+=+(new+Car)
+++++++->setColor('blue')
+++++++->setMake('Ford')
+++++++->setDrive('FWD');|1808344|这样，您就可以准确地选择要设置的属性。在很多方面，它类似于将一组选项传递给初始调用：|1808345|$car+=+new+Car(['make'+=>+'Ford',+'seats'+=>+5]);|1808346|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Fluent_interface#PHP^0|12|D|C|H|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@$9|13|A|14|1|15]]|E|$]]|$1|F|3|G|5|H|7|16|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|17|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|18|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|19|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1A|8|@]|D|@]|E|$I|J]]|$1|S|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]]]

For completeness, I'll suggest <a href="https://en.wikipedia.org/wiki/Fluent_interface#PHP" rel="noreferrer">Fluent Interfaces</a>. The idea is that by adding <code>return $this;</code> to the end of your methods you can chain calls together. So instead of

<pre><code>$car1 = new Car('blue', 'RWD');
$car2 = new Car('Ford', '300hp');
</code></pre>

(which simply wouldn't work), you can do:

<pre><code>$car = (new Car)
 -&gt;setColor('blue')
 -&gt;setMake('Ford')
 -&gt;setDrive('FWD');
</code></pre>

That way you can pick exactly which properties you want to set. In a lot of ways it's similar to passing in an array of options to your initial call:

<pre><code>$car = new Car(['make' =&gt; 'Ford', 'seats' =&gt; 5]);
</code></pre>

blocks|key|1593369|text|PHP确实不支持真正的重载。正如@Pestilence提到的，您可以使用变量参数。有些人只是使用各种选项的关联数组来克服这一点。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1593370|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

True overloading is indeed unsupported in PHP. As @Pestilence mentioned, you can use variable arguments. Some people just use an Associative Array of various options to overcome this.

blocks|key|1593678|text|他们说这是可行的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1593679|<?php
class+A
{
++++function+__construct()
++++{
++++++++$a+=+func_get_args();
++++++++$i+=+func_num_args();
++++++++if+(method_exists($this,$f='__construct'.$i))+{
++++++++++++call_user_func_array(array($this,$f),$a);
++++++++}
++++}

++++function+__construct1($a1)
++++{
++++++++echo('__construct+with+1+param+called:+'.$a1.PHP_EOL);
++++}

++++function+__construct2($a1,$a2)
++++{
++++++++echo('__construct+with+2+params+called:+'.$a1.','.$a2.PHP_EOL);
++++}

++++function+__construct3($a1,$a2,$a3)
++++{
++++++++echo('__construct+with+3+params+called:+'.$a1.','.$a2.','.$a3.PHP_EOL);
++++}
}
$o+=+new+A('sheep');
$o+=+new+A('sheep','cat');
$o+=+new+A('sheep','cat','dog');

//+results:
//+__construct+with+1+param+called:+sheep
//+__construct+with+2+params+called:+sheep,cat
//+__construct+with+3+params+called:+sheep,cat,dog
?>|code-block|syntax|javascript|1593680|而且，似乎每个人都很高兴，但对我来说，它不起作用……如果你让它工作，它也是一种重载……|1593681|它接受所有的参数并将它们传递给第二个函数构造函数...|1593682|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

they say this work:

<pre><code>&lt;?php
class A
{
 function __construct()
 {
 $a = func_get_args();
 $i = func_num_args();
 if (method_exists($this,$f='__construct'.$i)) {
 call_user_func_array(array($this,$f),$a);
 }
 }

 function __construct1($a1)
 {
 echo('__construct with 1 param called: '.$a1.PHP_EOL);
 }

 function __construct2($a1,$a2)
 {
 echo('__construct with 2 params called: '.$a1.','.$a2.PHP_EOL);
 }

 function __construct3($a1,$a2,$a3)
 {
 echo('__construct with 3 params called: '.$a1.','.$a2.','.$a3.PHP_EOL);
 }
}
$o = new A('sheep');
$o = new A('sheep','cat');
$o = new A('sheep','cat','dog');

// results:
// __construct with 1 param called: sheep
// __construct with 2 params called: sheep,cat
// __construct with 3 params called: sheep,cat,dog
?&gt;
</code></pre>

and, it seem every one are happy with it, but for me it didn't work...
if you get it to work, its one kind of overloading too...

it take all argoments and pass them to the secondary function constructor...

blocks|key|1808356|text|<?php
//php+do+not+automatically+call+parent+class+constructor+at+all+if+child+class+has+constructor+so+you+have+to+call+parent+class+constructor+explicitly,+however+parent+class+constructor+is+called+automatically+if+child+class+has+no+constructor
class+MyClass+
{
++++function+construct1($value1)
++++{
++++++++echo+" +dummy+constructor+is+called+with+1+arguments+and+it+is+$value1";
++++}
++++function+construct2($value1,$value2)
++++{
++++++++echo+" +dummy+constructor+is+called+with+2+arguments+and+it+is+$value1,+$value2";
++++}
++++function+construct3($value1,$value2,$value3)
++++{
++++++++echo+" +dummy+constructor+is+called+with+3+arguments+and+it+is+$value1,+$value2+,+$value3";
++++}+
++++public+function+__construct()
++++{
++++++++$NoOfArguments+=+func_num_args();+//return+no+of+arguments+passed+in+function
++++++++$arguments+=+func_get_args();
++++++++echo+" +child+constructor+is+called+$NoOfArguments";
++++++++switch+($NoOfArguments)+{
++++++++++++case+1:
+++++++++++++++++self::construct1($arguments[0]);
++++++++++++++++break;
++++++++++++case+2:
++++++++++++++++self::construct2($arguments[0],$arguments[1]);
++++++++++++++++break;

++++++++++++case+3:
++++++++++++++++self::construct3($arguments[0],$arguments[1],$arguments[2]);
++++++++++++++++break;

++++++++++++default:
++++++++++++++++echo+"Invalid+No+of+arguments+passed";
++++++++++++++++break;
++++++++}
++++}


}
$c+=+new+MyClass();
$c2+=+new+MyClass("ankit");
$c2+=+new+MyClass("ankit","Jiya");
$c2+=+new+MyClass("ankit","Jiya","Kasish");|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1808357|?>|unstyled|1808358|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>&lt;?php
//php do not automatically call parent class constructor at all if child class has constructor so you have to call parent class constructor explicitly, however parent class constructor is called automatically if child class has no constructor
class MyClass 
{
 function construct1($value1)
 {
 echo "&lt;br/&gt; dummy constructor is called with 1 arguments and it is $value1";
 }
 function construct2($value1,$value2)
 {
 echo "&lt;br/&gt; dummy constructor is called with 2 arguments and it is $value1, $value2";
 }
 function construct3($value1,$value2,$value3)
 {
 echo "&lt;br/&gt; dummy constructor is called with 3 arguments and it is $value1, $value2 , $value3";
 } 
 public function __construct()
 {
 $NoOfArguments = func_num_args(); //return no of arguments passed in function
 $arguments = func_get_args();
 echo "&lt;br/&gt; child constructor is called $NoOfArguments";
 switch ($NoOfArguments) {
 case 1:
 self::construct1($arguments[0]);
 break;
 case 2:
 self::construct2($arguments[0],$arguments[1]);
 break;

 case 3:
 self::construct3($arguments[0],$arguments[1],$arguments[2]);
 break;

 default:
 echo "Invalid No of arguments passed";
 break;
 }
 }


}
$c = new MyClass();
$c2 = new MyClass("ankit");
$c2 = new MyClass("ankit","Jiya");
$c2 = new MyClass("ankit","Jiya","Kasish");
</code></pre>

?>

blocks|key|1808056|text|您可以在构造函数中使用条件语句，然后执行任务。例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1808057|++class+Example
++{
++++++function+__construct($no_of_args)

++++++{//+lets+assume+2
++++++++++switch($no_of_args)
++++++++++{
++++++++++++++case+1:
++++++++++++++++//+write+your+code
++++++++++++++break;
++++++++++++++case+2:
++++++++++++++++//write+your+2nd+set+of+code
++++++++++++++break;
++++++++++++++default:
+++++++++++//write+your+default+statement
+++++++++}
++++++}
+++}

++++$object1+=+new+Example(1);++//+this+will+run+your+1st+case
++++$object2+=+new+Example(2);++//+this+will+run+your+2nd+case|code-block|syntax|javascript|1808058|以此类推。|1808059|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

You can use conditional statements in your constructor and then perform your task.
Eg.

<pre><code> class Example
 {
 function __construct($no_of_args)

 {// lets assume 2
 switch($no_of_args)
 {
 case 1:
 // write your code
 break;
 case 2:
 //write your 2nd set of code
 break;
 default:
 //write your default statement
 }
 }
 }

 $object1 = new Example(1); // this will run your 1st case
 $object2 = new Example(2); // this will run your 2nd case
</code></pre>

and so on...

blocks|key|1593958|text|当然，您可以使用__call()和__callStatic()魔术方法重载PHP中的任何函数。这有点棘手，但它的实现完全可以做你想要的事情。以下是PHP.net官方网站上的资源：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1593959|https://www.php.net/manual/en/language.oop5.overloading.php#object.call|offset|length|1593960|下面是既适用于静态方法又适用于非静态方法的示例：|1593961|class+MethodTest
{
++++public+function+__call($name,+$arguments)
++++{
++++++++//+Note:+value+of+$name+is+case+sensitive.
++++++++echo+"Calling+object+method+'$name'+"
+++++++++++++.+implode(',+',+$arguments).+"\n";
++++}

++++/**++As+of+PHP+5.3.0++*/
++++public+static+function+__callStatic($name,+$arguments)
++++{
++++++++//+Note:+value+of+$name+is+case+sensitive.
++++++++echo+"Calling+static+method+'$name'+"
+++++++++++++.+implode(',+',+$arguments).+"\n";
++++}
}

$obj+=+new+MethodTest;
$obj->runTest('in+object+context');

MethodTest::runTest('in+static+context');++//+As+of+PHP+5.3.0|code-block|syntax|javascript|1593962|您可以通过在__construct()中使用以下代码将其应用于构造函数：|1593963|$clsName+=+get_class($this);
$clsName->methodName($args);|1593964|很简单。您可能希望实现__clone()来使用您调用的方法复制类的克隆副本，而不必使用在每个实例中调用的函数……|1593965|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1Z|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|10|8|@]|9|@$D|11|E|12|1|13]]|A|$]]|$1|F|3|G|5|6|7|14|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|15|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|16|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|17|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|18|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|C]]]]

You can of course overload any function in PHP using __call() and __callStatic() magic methods.
It is a little bit tricky, but the implementation can do exactly what your are looking for.
Here is the resource on the official PHP.net website:

<a href="https://www.php.net/manual/en/language.oop5.overloading.php#object.call" rel="nofollow noreferrer">https://www.php.net/manual/en/language.oop5.overloading.php#object.call</a>

And here is the example which works for both static and non-static methods:

<pre><code>class MethodTest
{
 public function __call($name, $arguments)
 {
 // Note: value of $name is case sensitive.
 echo "Calling object method '$name' "
 . implode(', ', $arguments). "\n";
 }

 /** As of PHP 5.3.0 */
 public static function __callStatic($name, $arguments)
 {
 // Note: value of $name is case sensitive.
 echo "Calling static method '$name' "
 . implode(', ', $arguments). "\n";
 }
}

$obj = new MethodTest;
$obj-&gt;runTest('in object context');

MethodTest::runTest('in static context'); // As of PHP 5.3.0

</code></pre>

And you can apply this to constructors by using the following code in the __construct():

<pre><code>$clsName = get_class($this);
$clsName-&gt;methodName($args);
</code></pre>

Pretty easy.
And you may want to implement __clone() to make a clone copy of the class with the method that you called without having the function that you called in every instance...

blocks|key|1593034|text|据我所知，PHP中的构造函数重载是不允许的，因为PHP的开发人员没有包含该功能-这是PHP的许多抱怨之一。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1593035|我听说过一些技巧和变通方法，但还没有真正的OOP意义上的重载。也许在未来的版本中，它将被包括在内。|1593036|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

As far as I know, constructor overloading in PHP is not allowed, simply because the developers of PHP did not include that functionality - this is one of the many complaints about PHP.

I've heard of tricks and workarounds, but true overloading in the OOP sense is missing. Maybe in future versions, it will be included.

blocks|key|1593850|text|<?php

++++class+myClass+{

++++++++public+$param1+=+'a';
++++++++public+$param2+=+'b';

++++++++public+function+__construct($param1+=+NULL,+$param2+=+NULL)+{

++++++++++++if+($param1+==+NULL+&&+$param2+==+NULL)+{
//++++++++++++++++$this->param1+=+$param1;
//++++++++++++++++$this->param2+=+$param2;
++++++++++++}+elseif+($param1+==+NULL+&&+$param2+!==+NULL)+{
//++++++++++++++++$this->param1+=+$param1;
++++++++++++++++$this->param2+=+$param2;
++++++++++++}+elseif+($param1+!==+NULL+&&+$param2+==+NULL)+{
++++++++++++++++$this->param1+=+$param1;
//++++++++++++++++$this->param2+=+$param2;++++++++++++++++
++++++++++++}+else+{
++++++++++++++++$this->param1+=+$param1;
++++++++++++++++$this->param2+=+$param2;
++++++++++++}

++++++++}

++++}

//++++$myObject++=+new+myClass();
//++++$myObject++=+new+myClass(NULL,+2);
++++$myObject++=+new+myClass(1,+'');
//++++$myObject++=+new+myClass(1,+2);

++++echo+$myObject->param1;
++++echo+"<br+/>";
++++echo+$myObject->param2;

?>|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1593851|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>&lt;?php

 class myClass {

 public $param1 = 'a';
 public $param2 = 'b';

 public function __construct($param1 = NULL, $param2 = NULL) {

 if ($param1 == NULL &amp;&amp; $param2 == NULL) {
// $this-&gt;param1 = $param1;
// $this-&gt;param2 = $param2;
 } elseif ($param1 == NULL &amp;&amp; $param2 !== NULL) {
// $this-&gt;param1 = $param1;
 $this-&gt;param2 = $param2;
 } elseif ($param1 !== NULL &amp;&amp; $param2 == NULL) {
 $this-&gt;param1 = $param1;
// $this-&gt;param2 = $param2; 
 } else {
 $this-&gt;param1 = $param1;
 $this-&gt;param2 = $param2;
 }

 }

 }

// $myObject = new myClass();
// $myObject = new myClass(NULL, 2);
 $myObject = new myClass(1, '');
// $myObject = new myClass(1, 2);

 echo $myObject-&gt;param1;
 echo "&lt;br /&gt;";
 echo $myObject-&gt;param2;

?&gt;
</code></pre>

blocks|key|1594033|text|就当前PHP的完整性而言，添加此答案是因为PHP的后续版本，实际上您可以在某种程度上重载构造函数。下面的代码将有助于理解，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1594034|<?php
class+A
{
++++function+__construct()
++++{
++++++++$a+=+func_get_args();
++++++++$i+=+func_num_args();
++++++++if+(method_exists($this,$f='__construct'.$i))+{
++++++++++++call_user_func_array(array($this,$f),$a);
++++++++}
++++}
+++
++++function+__construct1($a1)
++++{
++++++++echo('__construct+with+1+param+called:+'.$a1.PHP_EOL);
++++}
+++
++++function+__construct2($a1,$a2)
++++{
++++++++echo('__construct+with+2+params+called:+'.$a1.','.$a2.PHP_EOL);
++++}
+++
++++function+__construct3($a1,$a2,$a3)
++++{
++++++++echo('__construct+with+3+params+called:+'.$a1.','.$a2.','.$a3.PHP_EOL);
++++}
}
$o+=+new+A('sheep');
$o+=+new+A('sheep','cat');
$o+=+new+A('sheep','cat','dog');
?>|code-block|syntax|javascript|1594035|输出：|1594036|__construct+with+1+param+called:+sheep
__construct+with+2+params+called:+sheep,cat
__construct+with+3+params+called:+sheep,cat,dog|1594037|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Adding this answer for completeness with respect to current PHP , since later versions of PHP , you can in fact overload constructors in a way . Following code will help to understand ,
<pre><code>&lt;?php
class A
{
 function __construct()
 {
 $a = func_get_args();
 $i = func_num_args();
 if (method_exists($this,$f='__construct'.$i)) {
 call_user_func_array(array($this,$f),$a);
 }
 }
 
 function __construct1($a1)
 {
 echo('__construct with 1 param called: '.$a1.PHP_EOL);
 }
 
 function __construct2($a1,$a2)
 {
 echo('__construct with 2 params called: '.$a1.','.$a2.PHP_EOL);
 }
 
 function __construct3($a1,$a2,$a3)
 {
 echo('__construct with 3 params called: '.$a1.','.$a2.','.$a3.PHP_EOL);
 }
}
$o = new A('sheep');
$o = new A('sheep','cat');
$o = new A('sheep','cat','dog');
?&gt;
</code></pre>
Output :
<pre><code>__construct with 1 param called: sheep
__construct with 2 params called: sheep,cat
__construct with 3 params called: sheep,cat,dog
</code></pre>

blocks|key|1594039|text|+public+function+construct1($user+,+$company)
{
++++dd("constructor+1");
++++$this->user+=+$user;
++++$this->company+=+$company;
}

public+function+construct2($cc_mail+,+$bcc_mail+,+$mail_data,$user,$company)
{
++++dd('constructor+2');
++++$this->mail_data=$mail_data;
++++$this->user=$user;
++++$this->company=$company;
++++$this->cc_mail=$cc_mail;
++++$this->bcc_mail=$bcc_mail;
}

public+function+__construct()
{
++++$NoOfArguments+=+func_num_args();+//return+no+of+arguments+passed+in+function
++++$arguments+=+func_get_args();
++++switch+($NoOfArguments)+{
++++++++case+1:
+++++++++++++self::construct1($arguments[0]);
++++++++++++break;
++++++++case+5:
++++++++++++self::construct2($arguments[0],$arguments[1],$arguments[2],$arguments[3],$arguments[4]);
++++++++++++break;
++++++++default:
++++++++++++echo+"Invalid+No+of+arguments+passed";
++++++++++++break;
++++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1594040|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code> public function construct1($user , $company)
{
 dd(&quot;constructor 1&quot;);
 $this-&gt;user = $user;
 $this-&gt;company = $company;
}

public function construct2($cc_mail , $bcc_mail , $mail_data,$user,$company)
{
 dd('constructor 2');
 $this-&gt;mail_data=$mail_data;
 $this-&gt;user=$user;
 $this-&gt;company=$company;
 $this-&gt;cc_mail=$cc_mail;
 $this-&gt;bcc_mail=$bcc_mail;
}

public function __construct()
{
 $NoOfArguments = func_num_args(); //return no of arguments passed in function
 $arguments = func_get_args();
 switch ($NoOfArguments) {
 case 1:
 self::construct1($arguments[0]);
 break;
 case 5:
 self::construct2($arguments[0],$arguments[1],$arguments[2],$arguments[3],$arguments[4]);
 break;
 default:
 echo &quot;Invalid No of arguments passed&quot;;
 break;
 }
</code></pre>

blocks|key|1594136|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1594137|interface+IExample+{

++++public+function+someMethod();

}

class+oneParamConstructor+implements+IExample+{

++++public+function+__construct(private+int+$someNumber)+{

++++}

++++public+function+someMethod(){

++++}
}

class+twoParamConstructor+implements+IExample+{

++++public+function+__construct(private+int+$someNumber,+string+$someString)+{

++++}

++++public+function+someMethod(){

++++}
}|code-block|syntax|javascript|1594138|而不是在代码中：|1594139|function+doSomething(IExample+$example)+{

++++$example->someMethod();

}

$a+=+new+oneParamConstructor(12);
$b+=+new+twoParamConstructor(45,+"foo");

doSomething($a)
doSomething($b)|1594140|entityMap^0|0|0|0|0^^$0|@$1|2|3|-4|4|5|6|L|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|M|7|@]|8|@]|9|$D|E]]|$1|F|3|G|4|5|6|N|7|@]|8|@]|9|$]]|$1|H|3|I|4|C|6|O|7|@]|8|@]|9|$D|E]]|$1|J|3|-4|4|5|6|P|7|@]|8|@]|9|$]]]|K|$]]

In this case I recommend using Interfaces:
<pre><code>interface IExample {

 public function someMethod();

}

class oneParamConstructor implements IExample {

 public function __construct(private int $someNumber) {

 }

 public function someMethod(){

 }
}

class twoParamConstructor implements IExample {

 public function __construct(private int $someNumber, string $someString) {

 }

 public function someMethod(){

 }
}
</code></pre>
than in your code:
<pre><code>function doSomething(IExample $example) {

 $example-&gt;someMethod();

}

$a = new oneParamConstructor(12);
$b = new twoParamConstructor(45, &quot;foo&quot;);

doSomething($a)
doSomething($b)
</code></pre>

blocks|key|1593375|text|我真的不是OOP专家，但据我所知，重载意味着一个方法能够根据它作为输入接收的参数而采取不同的行为。这在PHP中是很有可能的，你不需要声明输入类型，因为PHP没有强类型，而且所有的重载都是在运行时而不是编译时完成的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1593376|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I'm really no OOP expert, but as I understand it overloading means the ability of a method to act differently depending in the parameters it receives as input. This is very much possible with PHP, you just don't declare the input types since PHP does not have strong typing, and all the overloading is done at runtime instead of compile time.

I have abandoned all hope of ever being able to overload my constructors in PHP, so what I'd really like to know is why.

Is there even a reason for it? Does it create inherently bad code? Is it widely accepted language design to not allow it, or are other languages nicer than PHP?

Why can't I overload constructors in PHP?

我已经放弃了在PHP中重载构造函数的所有希望，所以我真正想知道的是为什么。这是有原因的吗？它本身就会产生糟糕的代码吗？它是被广泛接受的语言设计而不允许的，还是其他语言比PHP更好？

问为什么我不能在PHP中重载构造函数？
EN

回答 14

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么我不能在PHP中重载构造函数？EN

回答 14

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么我不能在PHP中重载构造函数？
EN