php 面向对象abstract，interface，重载，子类继承父类

面向对象的三个基本特征是：封装、继承、多态。

封装
　　封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

继承
　　面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。
　　通过继承创建的新类称为“子类”或“派生类”。
　　被继承的类称为“基类”、“父类”或“超类”。
　　继承的过程，就是从一般到特殊的过程。　　

 多态

　　多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。
　　实现多态，有二种方式，覆盖，重载。
　　覆盖，是指子类重新定义父类的虚函数的做法。

　　重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。php是不支持重载的

//php没有重载，可以用以下方法实现

class OverLoadTesting
{
        public function __construct()
        {
                $num = func_num_args();
                $args = func_get_args();
                if (!$args) $args = array();
              
                switch($num){
                        case 0:
                                $this->__call('__construct0', $args);
                                break;
                        case 1:
                                $this->__call('__construct1', $args);
                                break;
                        case 2:
                                $this->__call('__construct2', $args);
                                break;
                        case 3:
                                $this->__call('__construct3', $args);
                                break;
                        default:
                                throw new Exception();
                }
        }

        public function __construct0()
        {      //PHP_EOL   php中的换行
                echo "constructor 0" . PHP_EOL;
        }

        public function __construct1($a)
        {
                echo "constructor 1: " . $a . PHP_EOL;
        }

        public function __construct2( $a, $b)
        {
                echo "constructor 2: " . $a," ",$b . PHP_EOL;
        }

        public function __construct3( $a, $b, $c)
        {
                echo "constructor 3: " ,$a," ",$b," ",$c. PHP_EOL;
        }

        function __call($name, $arg)
        {
                return call_user_func_array(array($this, $name), $arg);
        }
}

$a = new OverLoadTesting(11,23);

抽象类 包含一个抽象方法的类成为抽象类，只是声明而未实现的方法。所有的抽象类必须继承。而且被继承的子类需要实现抽象类中所有的抽象方法。抽象类不能被直接使用，因为没有方法体，抽象方法是不能实例化的。（抽象类比普通类多了个抽象方法）

接口 是一些方法特征的集合，这些方法特征当然来自于具体方法，但是她们一般都是来自于一些系统中不断出现的方法，一个接口只有方法的特征也就是声明部分，并没有方法体。一个类虽然只能继承一个父类，但是一个类可以同时实现多个接口。

接口和抽象类的区别
接口是针对方法的，根据多个方法进行覆盖
抽象类是针对类的，根据多个共同属性进行抽象

//抽象类
abstract class b  {
    abstract function close();
    
    function open(){
        echo "<br>b";
    }    
}

class c extends b{
    function close(){
        echo "<br>c";
    }
}
$c = new c();
$c->close();

//接口
interface o {
    function start();
}

class p implements o {
    function start(){
        echo "<br>o";
    }
}

$p = new p();
$p->start();

//调用父类中的方法parent::方法名(); 或者父类名::方法名()
//$this->变量名;如果子类定义了此变量则输出子类中的值;否则则是父类中的变量
class g {
    public $name = "hello";
    
    function getName(){
        echo "<br>父类中方法";
    }
}

class h  extends g {
    public $name = 'world';
    function getName(){
        echo "<br>".$this->name;
        parent::getName();
    }
}

$h = new h();
$h->getName();