Php 中的函数重载和重写是什么？

小开

最佳答案

重载是定义具有相似签名但具有不同参数的函数。重写只与派生类相关，其中父类已经定义了一个方法，而派生类希望重写使用该方法。

在 PHP 中，只能使用魔法方法 __call重载方法。

重写的一个例子:

<?php


class Foo {
function myFoo() {
return "Foo";
}
}


class Bar extends Foo {
function myFoo() {
return "Bar";
}
}


$foo = new Foo;
$bar = new Bar;
echo($foo->myFoo()); //"Foo"
echo($bar->myFoo()); //"Bar"
?>

小开

当你使用不同的参数定义相同的函数名两次(或更多次)时，就会出现函数重载问题，例如:

class Addition {
function compute($first, $second) {
return $first+$second;
}


function compute($first, $second, $third) {
return $first+$second+$third;
}
}

在上面的示例中，函数 compute被两个不同的参数签名重载。* PHP 还不支持这一点。另一种方法是使用可选参数:

class Addition {
function compute($first, $second, $third = 0) {
return $first+$second+$third;
}
}

函数重写发生在扩展类并重写父类中存在的函数时:

class Substraction extends Addition {
function compute($first, $second, $third = 0) {
return $first-$second-$third;
}
}

例如，compute重写 Addition中设置的行为。

小开

严格地说，没有区别，因为你两者都做不到:)

函数重写可以用像 APD 这样的 PHP 扩展来完成，但是它已经过时了，而且 afaik 的最后一个版本不可用。

由于动态类型的原因，PHP 中的函数重载无法完成，比如，在 PHP 中，你不能“定义”变量为特定的类型。例如:

$a=1;
$a='1';
$a=true;
$a=doSomething();

每个变量都有不同的类型，但是您可以在执行之前知道类型(参见第4个)。作为比较，其他语言使用:

int a=1;
String s="1";
bool a=true;
something a=doSomething();

在上一个示例中，必须强制设置变量的类型(例如，我使用了数据类型“ something”)。

另一个在 PHP 中无法实现函数重载的“问题”是: PHP 有一个名为 func _ get _ args ()的函数，它返回当前参数的数组，现在考虑以下代码:

function hello($a){
print_r(func_get_args());
}


function hello($a,$a){
print_r(func_get_args());
}


hello('a');
hello('a','b');

考虑到这两个函数都接受任意数量的参数，编译器应该选择哪一个？

Finally, I'd like to point out why the above replies are partially wrong; 函数重载/重写不等于方法重载/重写。

如果方法类似于函数但是特定于类，在这种情况下，PHP 允许在类中重写，但是由于语言语义的原因，同样不允许重载。

总之，像 Javascript 这样的语言允许重写(但同样，不允许重载) ，但是它们也可能显示重写用户函数和方法之间的区别:

/// Function Overriding ///


function a(){
alert('a');
}
a=function(){
alert('b');
}


a(); // shows popup with 'b'




/// Method Overriding ///


var a={
"a":function(){
alert('a');
}
}
a.a=function(){
alert('b');
}


a.a(); // shows popup with 'b'

小开

PHP 5.x.x 不支持过载，这就是为什么 PHP 不是完全 OOP 的原因。

小开

尽管 PHP 不完全支持重载范例，但是默认参数可以达到相同(或非常相似)的效果(正如前面提到的那样)。

如果你像这样定义你的函数:

function f($p=0)
{
if($p)
{
//implement functionality #1 here
}
else
{
//implement functionality #2 here
}
}

当你调用这个函数时，比如:

f();

你会得到一个功能(# 1) ，但是如果你使用如下参数调用它:

f(1);

你会得到另一个功能(# 2)。这是重载的影响——根据函数的输入参数不同，有不同的功能。

我知道，现在有人会问，如果他/她调用这个函数为 f (0) ，那么会得到什么功能。

小开

超载示例

class overload {
public $name;
public function __construct($agr) {
$this->name = $agr;
}
public function __call($methodname, $agrument) {
if($methodname == 'sum2') {


if(count($agrument) == 2) {
$this->sum($agrument[0], $agrument[1]);
}
if(count($agrument) == 3) {


echo $this->sum1($agrument[0], $agrument[1], $agrument[2]);
}
}
}
public function sum($a, $b) {
return $a + $b;
}
public function sum1($a,$b,$c) {


return $a + $b + $c;
}
}
$object = new overload('Sum');
echo $object->sum2(1,2,3);

小开

我想在这里指出，与其他编程语言相比，PHP 中的重载具有完全不同的含义。很多人都说 PHP 不支持重载，而且根据重载的传统定义，是的，重载的功能并不明确可用。

但是，PHP 中重载的正确定义是完全不同的。

在 PHP 中，重载是指使用像 _ _ set ()和 _ _ get ()这样的神奇方法动态创建属性和方法。这些重载方法在与不可访问或未声明的方法或属性交互时被调用。

下面是 PHP 手册中的一个链接: http://www.php.net/manual/en/language.oop5.overloading.php

小开

虽然函数重载和重载都包含相同的函数名，但它们之间有一些区别。在重载中，相同名称的函数包含不同类型的参数或返回类型，例如: “ function add (int a，int b)”& “ function add (float a，float b) ; 这里，add ()函数被重载。在重写参数和函数名的情况下，它们是相同的，通常可以在继承或者特性中找到。因此，在重载程序员遵循一些策略，以执行所需的功能，在重载程序可以自动识别所需的功能... 谢谢！

小开

超载: 在现实世界中，超载意味着将一些额外的东西分配给某人。与现实中一样，PHP 中的重载意味着调用额外的函数。换句话说，你可以说它有一个不同参数的更薄的函数。在 PHP 中，你可以使用魔法函数重载，例如 _ _ get，_ _ set，_ _ call 等。

重载示例:

class Shape { const Pi = 3.142 ; // constant value function __call($functionname, $argument){ if($functionname == 'area') switch(count($argument)){ case 0 : return 0 ; case 1 : return self::Pi * $argument[0] ; // 3.14 * 5 case 2 : return $argument[0] * $argument[1]; // 5 * 10 } } } $circle = new Shape();`enter code here` echo "Area of circle:".$circle->area()."</br>"; // display the area of circle Output 0 echo "Area of circle:".$circle->area(5)."</br>"; // display the area of circle $rect = new Shape(); echo "Area of rectangle:".$rect->area(5,10); // display area of rectangle

重写: 在面向对象编程中，重写是替换子类中的父类方法。重写时，可以在子类中重新声明父类方法。因此，重写的基本目的是更改父类方法的行为。

重写的例子:

class parent_class { public function text() //text() is a parent class method { echo "Hello!! everyone I am parent class text method"."</br>"; } public function test() { echo "Hello!! I am second method of parent class"."</br>"; } } class child extends parent_class { public function text() // Text() parent class method which is override by child class { echo "Hello!! Everyone i am child class"; } } $obj= new parent_class(); $obj->text(); // display the parent class method echo $obj= new parent_class(); $obj->test(); $obj= new child(); $obj->text(); // display the child class method echo