类、面向对象、类的继承

类:

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

通常，一个类所具有的共同特征包括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();