类、面向对象、类的继承

类:

它是用于描述“某一些具备共同特征”的物体的概念，是某一类物体的总称。

一般，一个类所具备的共同特征包括2大方面的信息：

外观，形状，描述，数据。。。。。属性

行为，动做，功能。。。。。。。。方法

举例子：

人类；动物类；鸟类

对象:

 

它是指一个具体的“物体”，该物体隶属于某个“类别”（类）。

一般，对象离不开类，没有类，就不能有对象。

//建立类
class computer{
    //定义属性
    var $code ="c1";
    var $color ="black";
    //定义方法
    function show(){
        echo "这台电脑型号是：".$this->code."<br />"."颜色是：".$this->color."<br />";
    }
}
//建立类的对象
$com = new computer();
$com->code ="c2";
$com->color="中国红";
//调用类里面的方法
$com->show();
$com1 = new computer();
//$com1->code="c3";
//$com1->color="黄金黄";
$com1->show();

案例

建立对象的基本形式：

方式1：

$对象名1  =  new  类名（）； //对象名就是变量名；类是应该定义过了

 

方式2：

$CName = C1;

$person3=new $CName();

方式3：

$对象名3 = new  self; //self指代类自己，这行代码只能在类内部方法中使用。

 

方式4：

经过对象建立对象 new 对象名;//建立该对象所属类的一个新对象

$person4 = new $person3;

对象的传值:2种

 

值传递： 传递的时候，拷贝的是数据自己。默认都是值传递。

 

结果：传递完以后，有了2份一样的数据，但两个变量“相互独立”没有关系。

 

引用传递： 传递的时候，拷贝的是引用关系。须要使用“＆”才能实现引用传递。

 

结果：传递完以后，数据仍然只有一份，可是两个变量共同指向该数据。

对象的存储跟普通变量的存储有所区别：

普通变量：

对于对象（变量):

类中的成员：属性、方法、类常量

 定义形式：

形式3：     public  $v1;

形式4：     public   $2 = 2;

 

使用形式：

$对象->属性名；

 

注意：属性名前面没有$符号。

 

方法前能够加修饰词：ｐｕｂｌｉｃ，　ｐｒｏｔｅｃｔｅｄ，ｐｒｉｖａｔｅ，省略就算“public”

 

方法中$this关键字:

 

$this是一个“伪对象”，表明当前所属类的当前对象。

 

一个系统函数：ｇｅｔ＿ｃｌａｓｓ（对象）　

 

做用：得到某个对象的“所属类名”——结果只是一个类名字符串。

 

$class_name = get_class($p1); //结果多是：”Person”

静态属性：

属性前加关键字：static

静态属性就是：只隶属于类自己——也能够看作是全部对象的“共有数据”。

经过特殊的语法：::（双冒号语法，也叫范围解释符）

类::$静态属性名；

静态方法：

使用方法跟静态属性相似：

类名::静态方法名();

 

注意：$this在静态方法中不能使用。

 

ｓｅｌｆ：

含义：表明当前类

使用：一般只能在某个类的某个方法内部表明该类的名称。

构造方法：

1，该方法名字是固定的，为：_ _construct();注意：两个下划线

2，该方法必须是普通方法（不能是静态方法）

3，一般该方法应该是public

4，一般该方法中使用$this这个关键字来对属性进行赋值

5，当new 类名()的时候，实际上是在调用该构造方法

6，若是一个类中定义了构造方法，则实例化该类时就会调用该方法，且实例化时的参数须要跟构造方法的参数匹配

析构方法：

销毁信息：_ _destruct()

１，析构方法一般不太须要去定义。

２，析构方法不能调用。

３，析构方法不能有形参。

４，析构方法中能够用于清理一些在ｐｈｐ代码结束后不能清理的数据，如生成的文件。

对象销毁的几个情形：

脚本程序运行结束，自动销毁；

明确地unset()一个对象变量，则被销毁；

改变对象变量的值，被销毁；

 

实际上，更本质来讲，当一个对象（new 出来的对象）没有任何一个变量指向它的时候，该对象就会被自动销毁——天然，若是整个程序结束，也会销毁。

类的继承:

含义理解：某个类A具备某些特征，另外一个类B，也具备A类的全部特征，而且还可能具备本身的更多的一些特征，此时，咱们就能够实现：B类使用A的特征信息并继续添加本身的一些特有特征信息。（对象的属性多，类的属性最少）

 

Class jizuidongwu{
    public $prop1 = "有脊椎";
    function show1(){
        echo "<br />特征：" . $this->prop1;
    }

}
Class human extends jizuidongwu{
    public $prop2 = "两脚走路";
    function show2(){
        echo "<br />特征：" . $this->prop1;
        echo "<br />特征：" . $this->prop2;
    }
}
$person1 = new human();
$person1->show2();

例子：

 

基本概念:

继承：一个类从另外一个已有的类得到其特性，称为继承。

派生：从一个已有的类产生一个新的类，称为派生。

继承和派生，其实只是从不一样的方向（角度）来表述，本质上就是一个事情。

父类/子类：已有类为父类，新建类为子类。父类也叫“基类”，子类也叫“派生类”

单继承：一个类只能从一个上级类继承其特性信息。PHP和大多数面向对象的语言都是单继承模式。C++是多继承。

扩展：在子类中再来定义本身的一些新的特有的特性信息（属性，方法和常量）。没有扩展，继承也就没有意义了

访问（权限）修饰符:

在类中的成员，一般均可以在前面加上如下3个修饰符：

public：公共的，共有的，公开的

protected：受保护的

private：私有的，

public公有的:

 

语法模式：

 

对象->成员；

 

类名::成员；

 

访问位置分为3个：

 

1：某个类内部：天然是该类的某个方法中

 

2：某个类的具备继承关系的子（父）类的内部：是指其余类的某个方法中。

 

3，某个类的外部：通常就是独立的代码区（不在类中），相似咱们以前的代码。

 

class C{
    public $p1 = 1;
    public function showInfo(){
        echo "<br />属性p1=" . $this->p1;
        echo "<br />属性p2=" . $this->p2;//此时能够访问下级的$p2（但很不经常使用）
    }
}
class D extends C{
    public $p2 = 2;
    public function showInfo2(){
        echo "<br />属性p1=" . $this->p1;//访问的是上级的$p1（常见情形）
        echo "<br />属性p2=" . $this->p2;
    }
}
$d1 = new D();
$d1->showInfo2();
echo "<br />在类外p2=" . $d1->p2;
$d1->showInfo();

代码演示

 

protected 受保护的：

 

protected修饰的成员，能够在当前类或当前类的上下级具备继承关系的类中访问。

 

class C{
    protected $p1 = 1;
    public function showInfo(){
        echo "<br />属性p1=" . $this->p1;
    }
}
class D extends C{
    protected $p2 = 2;
    public function showInfo2(){
        echo "<br />属性p1=" . $this->p1;//访问的是上级的受保护成员$p1
        echo "<br />属性p2=" . $this->p2;//访问的是本身的受保护成员$p1
    }
}
$d1 = new D();
$d1->showInfo2();
echo "<br />在类外p2=" . $d1->p2;//这一行出错，由于在“外面”不能访问受保护成员$p2

代码演示

 

private私有的：

private 修饰的成员，只能在其所在的类中访问。

 

class C{
    private $p1 = 1;
    public function showInfo(){
        echo "<br />属性p1=" . $this->p1;
    }
}
class D extends C{
    private $p2 = 2;
    public function showInfo2(){
        echo "<br />属性p1=" . $this->p1;//访问的是上级的似有成员$p1
        echo "<br />属性p2=" . $this->p2;//访问的是本身的私有成员$p1
    }
}
$d1 = new D();
$d1->showInfo2();
echo "<br />在类外p2=" . $d1->p2;//这一行出错，由于在“外面”不能访问私有成员$p2

代码

 

访问修饰限定符的总结：

范围	本类内	继承关系类内	类外
public	能够	能够	能够
protected	能够	能够	不能够
private	能够	不能够	不能够

 

 parent表明父类：

 

对比：ｓｅｌｆ表明“本类”（本身当前类）

 

ｐａｒｅｎｔ一般用于在子类中调用父类的成员的时候使用，多数一般就是使用父类的“静态类”成员。

 

——由于ｐａｒｅｎｔ表明的类，而非对象。

class C{
    public $p1 = 1;
    function showMe(){
        echo "<br />我是父类，数据有：";
        echo "<br />C中p1=" . $this->p1;
    }
    function __construct($p1){
        $this->p1 = $p1;
    }
}
class D extends C{
    public $p2 = 2;
    function __construct($p1,$p2){
        //经典用法
        parent::__construct($p1);//调用父类的构造函数来初始化p1
        $this->p2 = $p2;    //初始化p2
    }
    function showMe2(){
        echo "<br />我是子类，数据有：";
        //基本用法：
        parent::showMe();//调用父类的showMe方法，
        echo "<br />D中p2=" . $this->p2;
    }
}
$d1 = new D(10,20);    //此时就须要尊照构造函数的参数结构来使用
$d1->showMe2();

parent关键字常见用法