本课程内容听都能理解,自己实际敲代码过程出错过几次;需要多次敲代码;
实例类的声明与实例化1
<?php
/**
* 编程1: 类声明与类的实例化；
*/
//类声明:class
class user{
}
//使用类前,实例化
$test=new user();
//给对象手工的方式添加属性和方法
$test->name='熊成浩';
$test->age=28;
$test->sex='男';
$test->hello=function (){
return '自定义的方法';
};
//访问对象成员(属性和方法)
echo $test->name,'---',$test->sex,'---',$test->age;
echo '<br>';
//访问方法
echo ($test->hello)();//自执行的函数，不建议使用
echo '<br>';
//使用回调方式来执行,正确的执行方法
echo call_user_func($test->hello);运行实例 »
点击 "运行实例" 按钮查看在线实例
实例类的声明与实例化2
<?php
class demo2
{
//声明类属性
public $name;
public $age=28;
protected $sex=2;//受保护成员 ，仅限本类或本类子类中访问，外部不可见，0为男，1为女 其他为保密
private $salary=4000;//私有成员，仅限在本类使用，子类和外部不可见
public function getSex()
{
//返回语义化的性别名称
if ($this->sex==0)
{
return '男';
}
elseif ($this->sex==1)
{
return '女';
}
else
{
return '保密';
}
// return ($this->sex==0)?'男' :'女';
}
public function getSalary(){
return ($this->salary<6000) ?'工资太低不好意思拿出来':$this->salary;
}
}
//实例化
$demo2=new demo2();
echo '年龄(公共)：',$demo2->age;
echo '<hr>';
echo '性别(受保护)：',$demo2->getSex();
echo '<hr>';
echo '工资(私有)：',$demo2->getSalary();
echo '<hr>';运行实例 »
点击 "运行实例" 按钮查看在线实例
实例类常量对象初始化属性的重载
<?php
//类常量
//对象初始化
//属性的重载
class demo3{
//类常量是对所有对象共享的数据
const SITE_NAME='我在PHP中文网学习';
//声明三个私有属性
private $name;
private $age;
private $sex;
//对象初始化(使用构造方法魔术方法)
//类实例化时会自动调用构造方法
public function __construct($name,$age,$sex)
{
$this->name=$name;
$this->age=$age;
$this->sex=$sex;
//执行方法show()
echo $this->show();
}
public function show()
{
return $this->name.'的性别是：'.$this->sex.',年龄是：'.$this->age;
}
//获取属性的重载方法
public function __get($name)
{
if ($name=='sex'){
return $name.'不允许查看';
}
return $this->$name;
}
//设置属性的重载方法
public function __set($name, $value)
{
if ($name=='sex')
{
return $name.'禁止修改名称';
}
$this->$name=$value;
}
//检测属性的重载方法
public function __isset($name)
{
if ($name=='anme')
{
return false;//返回false后在输出时再次通过三元运算符显示字符串
}
return isset($this->$name);
}
//销毁属性的重载方法
public function __unset($name)
{
if ($name=='name')
{
return false;
}
unset($this->$name);
}
}
//访问类常量
echo demo3::SITE_NAME;
echo '<hr>';
//实例化
$test=new demo3('小王',28,'男');
var_dump($test);
echo '<hr>';
$test2=new demo3('小红',18,'女');
//属性重载的4种场景：获取，设置，检测，销毁
//当从类的外部访问类中不存在或无权访问的属性时，这些重载方法会被自动触发
echo '<hr>';
echo '获取性别：',$test2->sex;
echo '<hr>';
echo '获取名称：',$test2->name;
echo '<hr>';
echo '设置前的值：'.$test2->name;
echo '<br>';
$test2->name='小李子';
echo '设置后的值：'.$test2->name;
echo '<hr>';
echo '设置前的值：'.$test2->age;
$test2->age='19';
echo '<br>';
echo '设置后的值：'.$test2->age;
echo '<hr>';
echo isset($test2->age) ? '检测：存在' : '检测：不存在';
echo '<br>';
echo isset($test2->sss)?'检测：存在':'检测：不存在';
echo '<hr>';
echo '销毁前输出：'.$test2->name;
echo '<br>';
unset($test2->name);
echo '销毁后输出：'.$test2->name;
echo '<hr>';
echo '销毁前输出：'.$test2->age;
echo '<br>';
unset($test2->age);
echo '销毁后输出：'.$test2->age;
echo '<hr>';运行实例 »
点击 "运行实例" 按钮查看在线实例
实例继承与方法重写
<?php
//对象三要素：继承与多态
//1、继承是指类之间的继承，代码复用的字段
//2、继承关键字:extends
//3、引用父类成员:parent::
//4、子类可以将父类中公共和受保护的成员继承,public 公共 protected 受保护
//设置父类 基类 超类
class demo4
{
//设置父属性
public $name;
private $salary;
protected $age;
const APP_NAME='学生管理系统';//类常量可以在子类中重写
//父类的构造器
public function __construct($name,$age)
{
$this->name=$name;
$this->age=$age;
}
// //属性检测重载
// public function __isset($name)
// {
// if (isset($this->name))
// {
// return false;
// }
// return isset($this->$name);
// }
}
//重载方法必须写到工作类当中，new的是谁谁就是工作类
//设置子类 派生类
class demo4_1 extends demo4
{
//子类自有属性定义
private $sex;
const APP_NAME='教师管理系统';//类常量可以在子类中重写
//将父类中的构造方法进行重写
public function __construct($name,$age,$sex)
{
// $this->name=$name; //这样写代码冗余
// $this->age=$age;
parent::__construct($name, $age);//应该使用parent关键字引用，把参数传入
$this->sex=$sex;
}
//属性访问重载
public function __get($name)
{
if (isset($this->$name)){
return $this->$name;
}
return '非法访问';
}
}
//当前的工作类就是就是子类，需要把上面的重载方法写到下面
$demo4_1 = new demo4_1('haozi',18,'男');
echo $demo4_1->name;
echo '<br>';
echo $demo4_1->age;
echo '<br>';
echo $demo4_1->aa;
echo '<br>';
echo $demo4_1->sex;
echo '<hr>';
//类常量可以在子类中重写
echo '父类中的常量：'.demo4::APP_NAME;
echo '<br>';
echo '子类中的常量：'.demo4_1::APP_NAME;运行实例 »
点击 "运行实例" 按钮查看在线实例
实例类中静态成员的声明与访问
<?php
class demo5
{
public static $pdo=null;
protected static $db=[
'type' => 'mysql',
'host' => '127.0.0.1',
'dbname' => 'php',
'user' => 'root',
'pass' => 'root',
];
public static function connect(){
$dsn=self::$db['type'].':host='.self::$db['host'].';dbname='.self::$db['dbname'];
$user=self::$db['user'];
$pass=self::$db['pass'];
self::$pdo=new PDO($dsn,$user,$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);
}
}
//连接数据库
demo5::connect();
var_dump(demo5::$pdo);
//数据表查询
$result=demo5::select('user','name,password,email',10);
echo '<pre>';
echo var_export($result);运行实例 »
点击 "运行实例" 按钮查看在线实例
面向对象的三大特征：封装、继承、多态
封装的基本知识：
1、封装的本质，就是对象成员的访问进行限制
2、类成员：类属性，类方法
3、类成员的访问限制:3p public公共 protected受保护 private私有
4、如果成员被限制外部访问，那么应该提供公共访问接口
5、类中对象对实例化成员的访问：伪变量 $this.当前类的实例对象
属性重载的4种场景：__get获取，__set设置，__isset检测，__unset销毁
当从类的外部访问类中不存在或无权访问的属性时，这些重载方法会被自动触发
设置父类子类，重载方法必须写到工作类当中，new的是谁谁就是工作类
类中的静态成员与访问
1.类中静态成员使用关键字:static 定义;
2.静态成员包括: 静态属性和静态方法;
3.静态成员是属于类的,我们应该终终使用类来访问;
4.静态属性必须使用类来访问,而静态方法即可以用类,也可以用对象访问;
5.静态成员是可以有访问限制的: public,protected,private;
6.静态成员与对象无关,所以内部不允许使用伪变量: $this;
7.访问时,类名后必须使用:范围解析符:双冒号[::]
8.在类中引用自身使用关键字: self::
范围解析符的作用:
1. 访问静态成员;
2. 访问类常量;
3. 继承上下文中引用被覆盖成员
