1、以下代码是类的声明与实例化的知识，主要使用到了类的声明主要使用关键字class，类的实例化主要用到关键字new,对象的成员反问符使用：->来实现：
实例
<?php
/**
* 类的声明与实例化
* 1. 类声明: class;
* 2. 类的实例化: new
* 3. 对象成员的访问:->
*/
//用关键字class声明一个类
class Stu{
}
//用关键字 new 实例化一个类
$stu = new Stu();
//给当前对象添加一些属性和方法
$stu->name = "王豪杰";
$stu->sex = "男";
$stu->hello = function (){
return "这是一个自定义的类方法";
};
//使用对象访问符:-> 来访问对象中的成员(属性和方法)
echo $stu->name.':'.$stu->sex.'<br>';
//错误的调用方式,因为当前对象方法不是一个普通函数,而是一个对象方法
// echo $stu->hello();
//正确的调用方式,对象方法应该以回调的方式运行
echo call_user_func($stu->hello);
?>运行实例 »
点击 "运行实例" 按钮查看在线实例
说明：以上代码主要介绍了类的声明与实例化的知识点，是面向对象的基础知识，需要熟练的掌握才能进一步学习更多面向对象的知识。
2，一下代码主要介绍了类常量和类属性的重载知识点：
实例
<?php
/**
* 类常量,对象初始化,属性的重载
* 1. 类常量可用来创建对象之间的共享数据
* 2. 对象初始化: 用构造方法实现,创建对象之前会自动调用,完成对象的一些初始化工作
* 例如:对象属性初始化,创建对象时自动调用的方法等,方法名称固定:__construct()
* 3.属性重载:在类的外部访问不存在或者无权限访问的属性时,会自动触发此类方法调用
* 属性重载涉及四个方法:__get(),__set(),__isset(),__unset()
*/
class Student{
//类常量:所有对象共享,用类名加范围解析符(::)访问,且默认为公共属性public
//类常量可用来创建对象之间的共享数据
const COURSE_NAME = 'php中文网';
//声明三个私有的属性
private $name;
private $course;
private $grade;
//构造方法
public function __construct($name,$course,$grade)
{
$this->name = $name;
$this->course = $course;
$this->grade = $grade;
//构造方法中不仅可以初始化对象属性，还可以调用类方法
echo $this->show();
}
//输出属性内容
public function show(){
return $this->name .'的《'.$this->course.'》课程的成绩是：'.$this->grade.'分！';
}
//更新属性的重载，魔术方法__set()
public function __set($name,$value){
if($name == 'grade'){
return $name.':属性不能修改';
}
$this->$name = $value;
}
//获取属性的重载
public function __get($name){
if($name == 'grade'){
return $name.':属性不存在';
}
return $this->$name;
}
//属性检测的重载
public function __isset($name){
if ($name == 'course') {
return false;
}
return isset($this->$name);
}
//销毁属性的重载
public function __unset($name)
{
if ($name == 'grade' || $name == 'name') {
return false;
}
unset($this->$name);
}
}
//访问类常量:类常量可以被该类的所有对象所共享,所以不属于任何一个对象,应该使用类来访问
echo '站点名称: ', Student::COURSE_NAME, '<br>';
//实例化Student，创建对象
$stu = new Student('小豪','PHP',100);
var_dump($stu);
//访问属性,因为属性全部被封装,所以必须通过一个统一的外部接口访问
echo $stu->show();
echo'<hr>';
//如果想简化以上操作,可以在实例化之前,在构造方法中调用属性访问接口方法
new Student('小杰','PHP', 99);
echo '<hr>';
//属性操作: 获取,设置,检测,销毁
//获取
echo '姓名: '.$stu->name.'<br>';// 访问私有属性,如类中无__get()会出错,如有自动触发
echo '成绩: '.$stu->grade.'<br>'; // 可以在__get()进行属性访问的权限控制
//设置
$stu->course = 'Java';
echo '课程: '. $stu->course.'<br>';// 访问私有属性,如类中无__set()会出错,如有自动触发
$stu->grade = 66;
//检测,因为grade私有,所以外部检测不到,如类中有__isset()方法就可以检测到
echo isset($stu->name) ? '存在<br>' : '<span style="color:red">不存在</span><br>';
echo isset($stu->grade) ? '存在<br>' : '<span style="color:red">不存在</span><br>';
//销毁
unset($stu->course);
//echo $stu->course,'<br>'; //解除注释，就会报错提示该属性不存在
unset($stu->name); // 重载方法中__unset()不允许销毁grade和name属性
echo $stu->name,'<br>'; // 所以这里仍可以访问到name属性运行实例 »
点击 "运行实例" 按钮查看在线实例
运行截图：
说明：以上代码通过实例实现了类常量和类属性的重载技术：其中类常量可用来创建对象之间的共享数据，在类的外部访问不存在或者无权限访问的属性时,会自动触发魔术方法方法调用，重载包含上的系统函数主要有四个：__get(),__set(),__isset(),__unset()。
3，以下代码主要介绍了类的继承与方法重写，继承关键字为extends：
实例
<?php
/**
* 对象三要素之: 继承与多态
* 1. 继承是指类之间的继承,是代码复用的重要手段,之前我们是通过"函数"实现的代码复用
* 2. 继承使用关键字: extends
* 3. 引用父类成员: parent::
* 4. 子类可以将父类中的公共和受保护成员全部继承
*/
class Teacher{
//父类属性
public $name;
public $age;
private $grade;
const APP_NAME = '教师管理系统';
//父类构造器
public function __construct($name ,$age){
$this->name = $name;
$this->age = $age;
}
//属性访问重载
public function __get($name){
if(property_exists($this, $name)){
return $this->$name;
}
return '<br>属性不存在';
}
}
class Student extends Teacher {
//子类自有属性
private $sex;
const APP_NAME = '学生管理系统'; //类常量可以在子类中重写
//子类将父类同名方法进行重写,根据传入参数不同,实现不同的功能,这就是多态性
public function __construct($name, $age, $sex='male')
{
// $this->name = $name;
// $this->age = $age;
//引用父类的构造方法来简化代码
parent::__construct($name, $age);
$this->sex = $sex;
}
//将父类属性重载方法重写后,顺利读取子类属性
//所以属性重载方法__get()应该设置在最终工作类中(例如本类Demo4_1),而不是父类Demo4中
//此时,将父类Demo4中的__get()删除,代码执行仍然正确
public function __get($name)
{
if (property_exists($this, $name)) {
return $this->$name;
}
return '属性不存在<br>';
}
}
$stu = new Student('whj',24);
//访问父类中的属性
echo $stu->name.'<br>';
echo $stu->age.'<br>';
echo $stu->grade.'<br>'; // 父类私有属性子类不可见,访问不到
echo Student::APP_NAME. '<br>'; // 访问类常量
echo $stu->sex. '<br>'; //取不到值,因为父类__get()不能识别子类属性运行实例 »
点击 "运行实例" 按钮查看在线实例
说明：继承是指类之间的继承,是代码复用的重要手段，继承使用关键字: extends，引用父类成员: parent::值得注意的是子类继承父类只可以将父类中的公有和受保护的成员全部继承，另外子类将父类同名方法进行重写,根据传入参数不同,实现不同的功能,这就是多态性；
4，以下代码主要介绍了类中静态成员的声明与访问，其中静态成员声明的关键字为static：
实例
<?php
/**
* 类中的静态成员与访问
* 1.类中静态成员使用关键字:static 定义;
* 2.静态成员包括: 静态属性和静态方法;
* 3.静态成员是属于类的,我们应该最终使用类来访问;
* 4.静态属性必须使用类来访问,而静态方法即可以用类,也可以用对象访问;
* 5.静态成员是可以有访问限制的: public,protected,private;
* 6.静态成员与对象无关,所以内部不允许使用伪变量: $this;
* 7.访问时,类名后必须使用:范围解析符:双冒号[::]
* 8.在类中引用自身使用关键字: self::
*
* 范围解析符的作用:
* 1. 访问静态成员;
* 2. 访问类常量;
* 3. 继承上下文中引用被覆盖成员
*/
class Demo{
public static $pdo = null;
protected static $db = [
'type' => 'mysql',
'host' => 'localhost',
'dbname' => 'db100',
'user' => 'root',
'pass' => 123456
];
public static function connect(){
$dsn = self::$db['type'].':host='.self::$db['host'].';dbname='.self::$db['dbname'];
self::$pdo = new PDO($dsn,self::$db['user'],self::$db['pass']);
}
public static function select($table,$fields='*',$num=5)
{
$stmt = self::$pdo->prepare("SELECT {$fields} FROM {$table} LIMIT {$num}");
$stmt->execute();
return $stmt->fetchAll(PDO::FETCH_ASSOC);
}
}
//连接数据库
Demo::connect();
//查询数据库
$result = Demo::select('user','name,id,password',5);
//显示结果
echo '<pre>'.var_dump($result);运行实例 »
点击 "运行实例" 按钮查看在线实例
说明：静态成员是属于类的,我们应该最终使用类（self）来访问，静态属性必须使用类来访问,而静态方法即可以用类,也可以用对象访问；静态成员与对象无关,所以内部不允许使用伪变量: $this。
总结：今天学习了关于面向对象的第一个，也是最基础的东西。类的声明和实例化，以及类常量和属性的重载和类的继承与方法的重写，还有静态变量的使用，类的三大特征封装，继承，和多态，这些特征使得类的使用变得非常的灵活和多变，只有掌握好最最基础的知识点才能在使用的时候信手拈来，还是需要多动手敲代码，熟能生巧就是这个道理。
