0506oop作业

1. 类(对象抽象化的结果)与对象 (类实例化结果)

1、对象是具体存在的事物，对象是由属性（变量）和方法（函数）组成的
2、类是具有相同属性和行为的一组对象的集合
创建类
语法：
class 类名{ //属性 //方法 //常量 }
类是由属性、方法、常量组成的，也可以说
类成员有：属性、方法、常量
类名的命名规则：
以字母、下划线开头，后面跟的是字母、数字、下划线
不能用PHP关键字做类名
类名不区分大小写（变量名区分，关键字、类名不区分大小写）
类名用帕斯卡命名法（大驼峰 单词的首字母大写
对象实例化
通过new关键字来实例化对象。

2. 构造方法

构造方法也叫构造函数，当实例化对象的时候自动执行。 语法：
function __construct(){ }
注意：前面是两个下划线
构造函数作用：初始化成员变量
注意：构造函数可以带参数，但不能有return。

class Student
{
    private $name;
    private $sex;
    //构造函数初始化成员变量
    public function __construct($name,$sex)
    {
        $this->name=$name;
        $this->sex=$sex;
    }
    //显示信息
    public function show()
    {
        echo "姓名：{$this->name}<br>";
        echo "性别：{$this->sex}<br>";
    }
}
//实例化
$stu=new Student('tom','男');
$stu->show(); //输出 姓名：tom 性别：男

3. 对象成员之间的内部访问 $this

$this表示当前对象的引用，也就是$this保存的当前对象的地址

class A
{
    public $sttr;
    public function getSttr()
    {
        return $this->sttr;
    }
}
$a = new A();
$a->sttr = '属性';
echo $a->getSttr();  //输出 属性

4. private仅限本类中使用 protected本类中,子类中使用

访问修饰符
用来控制成员的访问权限

修饰符	描述
public（公有的）	在类的内部和外部都能访问
private（私有的）	只能在类的内部访问
protected（受保护的）	在整个继承链上访问

一般来说，属性都用私有的，通过公有的方法对私有的属性进行赋值和取值。

class Animal
{
    // 公有
    public $name;
    // 保护
    protected $type;
    // 私有
    private $dna;
    // 构造方法
    public function __construct($name,$type,$dna)
    {
        $this->name = $name;
        $this->type = $type;
        $this->dna = $dna;
    }
    // 公有方法对私有属性取值
    public function getDna()
    {
        return $this->dna;
    }
}
// 子类extend继承
class Dog extends Animal
{   // 子类未定义构造方法,默认调用父类的
    // 子类通过公有方法对保护属性取值
    public function getType()
    {
        return $this->type;
    }
    public function getDna()
    {
        parent::getDna();
    }
}
// 子类对象
$husky = new Dog('哈士奇','husky','002001');
echo $husky->name;  //输出 '哈士奇'
//echo $husky->type;  //错误
//echo $husky->dna;   //错误
echo $husky->getDna();  // 无输出,子类拿不到父类的私有
echo $husky->getType();  // 输出 husky
// 父类对象
$cat = new Animal('mimi','cat','001');
echo $cat->getDna();  // 输出002

5. 类的自动加载 spl_autoload_register

类的规则
一个文件中只能放一个类（必须）
文件名和类名同名（必须）
类文件以.class.php结尾（不是必须

• 手动加载类
  require ‘类文件路径’

• 自动加载类

  当缺少类的时候自动的调用autoload()函数，并且将缺少的类名作为参数传递给autoload()。

function __autoload($class_name)
{
    require $class_name.'php';
}

• 注册加载类
  通过spl_autoload_register($callback)注册__autoload()函数

spl_autoload_register(function ($class_name)
{
    require $class_name.'.php';
}
);

可以注册多个自动加载函数

spl_autoload_register('load1');
spl_autoload_register('load2');
spl_autoload_register('load3');
function load1($className)
{
    require $className.'.php';
}
function load2($className)
{
    require $className.'.class.php';
}
function load3($className)
{
    require $className.'.fun.php';
}

6. 静态成员的访问 类的引用self::

static修饰的属性叫静态属性、static修饰的方法叫静态方法
静态成员加载类的时候分配空间，程序执行完毕后销毁
静态成员在内存中就一份。
调用语法 类名::属性 类名::方法名()
self表示所在类的类名，使用self降低耦合性

class Cat
{
    //静态属性
    static $type;
    //静态方法设置静态属性
    public static function setType($type)
    {
        self::$type = $type;
    }
    //静态方法获得静态属性
    public static function getType()
    {
        return self::$type;
    }
}
Cat::$type = '波斯猫';
echo Cat::$type;  //输出 波斯猫
Cat::setType('招财猫');
echo Cat::getType();  //输出 招财猫

7. 类的继承 扩展 父类方法(魔术方法,普通方法)的重写 parent:: 调用父类成员

1. 继承介绍
   继承使得代码具有层次结构
   子类继承了父类的属性和方法，实现了代码的可重用性。
   使用extends关键字实现继承
   父类和子类是相对的
   语法 :
   class 子类 extends 父类{ }
2. 子类中调用父类成员
   1、方法一：通过实例化父类调用父类的成员
   2、方法二：通过$this关键字调用父类的成员
3. protected
   protected：受保护的，在整个继承链上使用
4. 继承中的构造函数
   规则：
   1、如果子类有构造函数就调用子类的，如果子类没有就调用父类的构造函数。
   2、子类的构造函数调用后，默认不再调用父类的构造函数
   可通过parent调用父类的构造函数
   parent::__construct()
5. $this详解
   $this表示当前对象的引用，也就是$this保存的当前对象的地址
6. 多重继承
   PHP不允许多重继承，因为多重继承容易产生二义性
   如何实现C继承A和B，使用继承链

// 父类
class Human
{
    public $name;
    public function __construct($name)
    {
        $this->name = $name;
    }
    public function say()
    {
        return $this->name.' say: hello!';
    }
}
// 子类
class Chinese extends Human
{
    private $nationality = 'CN';
    private $ethnicity;
    public function __construct($name,$ethnicity)
    {
        // 调用父类构造方法后, 加入自
        parent::__construct($name);
        $this->ethnicity = $ethnicity;
    }
    // 重写父类say方法
    public function say()
    {
        return parent::say() . "你好?";
    }
    // 获得属性
    public function getAttr()
    {
        return "国籍:{$this->nationality},民族:{$this->ethnicity}";
    }
}
// 实例化子类
$people = new Chinese('张三', '汉');
echo $people->name; //输出  张三
echo $people->say();  //输出 张三say:hello!你好?
echo $people->getAttr(); //输出  国籍:CN,民族:汉