1.final类和final
final 类不能被继承,final方法可以被继承,但是不能被子类重写
2. 三种权限讲解
场景 | public | protected | private |
---|---|---|---|
外部访问 | Y | N | N |
本类中调用 | Y | Y | Y |
子类中调用 | Y | Y | N |
3. 静态属性和方法(static)
属性和方法前面加static就可以不用实例化可以直接访问,访问方式:
类名::属性名/方法名()
4. 类常量(const)
使用const定义类中常量
类中调用自己的常量用类名::常量名
类中调用全局常量直接使用常量名
define('PI',3.1415926);
class Math{
const PI = 3.14;
public function test(){
echo Math::PI.'<br>';
}
public function test1(){
echo PI;
}
}
$math=new Math();
$math->test();
$math->test1();
//输出结果
3.14
3.1415926
5. 单例模式
思路:
- 当实例化一个类时,就会自动访问construct方法,需要阻止外部直接实例化,给construct加protected权限
- 开放一个接口用来实例化本类,然后让外部访问这个类,但是不实例化的话访问不了内部方法,所以就需要给接口的方法设置为静态的,通过类名直接访问
- 在接口方法中进行判断,此类是否被实例化,有的话直接返回,没有实例化之后返回
class Single {
static protected $_ins;
protected function __construct() {
$this->rand = mt_rand(10000,99999);
}
static public function getIns() {
if(Single::$_ins === null) {
Single::$_ins = new Single();
}
return Single::$_ins;
}
}
$a = Single::getIns();
$b = Single::getIns();
print_r($a);
print_r($b);
exit;
//访问的两次结果一样
但是目前还是有缺陷,当用一个类继承时,重写一个构造方法,此类就可以随便继承了,如下:
class Single {
static protected $_ins;
protected function __construct() {
$this->rand = mt_rand(10000,99999);
}
static public function getIns() {
if(Single::$_ins === null) {
Single::$_ins = new Single();
}
return Single::$_ins;
}
}
class Fs extends Single{
public function __construct(){
}
}
$c = new Fs();
$d = new Fs();
print_r($c);
print_r($d);
//两次结果不一样
所以需要对上述类进行修改,防止构造方法被重写,加上final进行限制
class Single {
static protected $_ins;
//final方法被继承后不能被修改
final protected function __construct() {
$this->rand = mt_rand(10000,99999);
}
static public function getIns() {
if(Single::$_ins === null) {
Single::$_ins = new Single();
}
return Single::$_ins;
}
}
6. self与parent
$this 代表本对象
self 代表本类 (主要用于单例时不实例化而是用类访问用)
parent 代表 父类(用于继承的时候,想要重写父类,但是还想要保留父类的方法)
class Single {
protected $ins = null;
protected function __construct() {
$this->rand = mt_rand(10000,99999);
}
public static function getIns() {
if(self::$_ins === null) {
self::$_ins = new self();
}
return self::$_ins;
}
}
class Par {
public function __construct() {
echo mt_rand(10000,99999).'<br />';
}
}
class Son extends Par {
public function __construct() {
//ThinkPHP 注意
parent::__construct();
echo '1'.'<br />';
}
}
7. 魔术方法
__construct(): 构造方法,new实例化时,自动调用
__destruct(): 析构方法,对象摧毁时自动调用
__get(属性名):当读取对象的一个不可见属性时,自动调用,并返回值
不可见:未定义或者无权访问时
__set(属性名,属性值):当对一个不可见的属性赋值时,自动调用
__isset(属性名) : 当用isset,或者empty判断一个不可见的属性时,自动调用
__unset(属性名): 当unset一个不可见属性时,自动调用
<?php
class Human {
private $age = 9;
public $school = 'PKU';
public function __get($a) {
echo 'you want get my $' , $a , '<br />';
return 3;
}
public function __set($per , $value) {
echo 'you want to set my ' ,$per ,' to ' , $value , '<br />';
}
public function __isset($per) {
return true;
}
public function __unset($per) {
echo 'you want to unset my ' , $per;
}
}
$a= new Human();
echo $a->age;//=>you want get my $age 换行 3
echo $a->name;//=>you want get my $name 换行 3
$a->age='20';//=>you want to set my age to 20
$a->name='jjd';//=>you want to set my name to jjd
var_dump(isset($a->name));//=>bool(true)
var_dump(isset($a->age));//=>bool(true)
unset($a->name);//=>you want to unset my name
unset($a->age);//=>you want to unset my age
8. 魔术方法的作用
对于下面那个类来说,外部可以随意设置、添加、修改、删除属性,类本身失去了对属性的控制权
class Foo {
}
$foo = new Foo();
$foo->age = 9;
print_r($foo); // Foo Object ( [age] => 9 )
需要做如下修改
class Bar {
public function __set($per , $value) {
//一般用于做些判断,那些私有属性可以删除
echo '我想知道你想设置' , $per,'为' , $value , '<br />';
echo '但设不设置看我的心情<br />';
}
}
$bar = new Bar();
$bar->age = 9;
print_r($bar);//=>我想知道你想设置age为9
//但设不设置看我的心情
//Bar Object ( )
9. 自动加载
其他文件中实例化某个类时,需要提前用require,include引入文件,这样类比较多,目录也比较多,很麻烦,所以引入了自动加载
思路:
声明一个函数,并注册为"自动加载函数"。
当系统发现某个类不存在时,会调用此函数,此函数中加载需要的类文件
//用于调用文件中的类$class时类名(所以类名和文件名要一致,这样才能引进对应类)
function myLoad($class) {
require('./' . $class . '.php');
}
//定义了一个注册函数,当实例化的类不存在时去走注册函数
spl_autoload_register('myLoad');
//实例化一个对象,检测到本文件没有,会跳到spl函数
new mysql();
10. 抽象类
类前面加上abstract就是抽象类 方法前面加上abstract就是抽象方法 抽象方法没有方法体(没有大括号)
抽象类中也可以有已经实现的方法(此方法必须是public),但只要有一个抽象方法,此类就是抽象类
抽象类不能被实例化
当抽象类被继承时,子类必须全部实现父类的抽象方法,否则子类还是抽象类
语法如下:
abstract class aDB {
abstract public function getRow($sql);
abstract public function getAll($sql);
abstract public function Exec($sql);
}
class MySQL extends aDb {
}
抽象类的意义
在实际开发中,因为时多人写作,负责的地方不一样,工作有先后或者争议,这样就可以在定义一个模板(抽象类),其中严格的规定方法名,参数,返回值,这样就可以开始工作了。后期确定好之后在更改就可以了。
11. 接口的概念
抽象类可以理解为‘类的模板’,接口则是‘方法’的模板,主要用于描述通用的方法
定义和语法如下:
//定义几个接口
interface flyer {
public function fly($oil , $height);
}
interface runer {
public function run($cicle , $dir);
}
interface water {
public function swim($dir);
}
//声明一个类,想用一些通用的方法,获取上面部分或全部接口来使用
//只要调用了接口,就要全部实现其方法
class Super implements flyer , runer , water {
public function fly($oil , $height) {
echo 'I am flying';
}
public function run($cicle , $dir) {
echo 'I am flying';
}
public function swim($dir) {
echo 'I am flying';
}
}
$s = new Super();
12. 错误异常(一般在不该出错的时候用,如 连接数据库)
function t1() {
if(rand(1,10) > 5) {
throw new Exception("我", 1);
} else {
return t2();
}
}
function t2() {
if(rand(1,10) > 5) {
throw new Exception("你", 2);
} else {
return t3();
}
}
function t3() {
if(rand(1,10) > 5) {
throw new Exception("他", 3);
} else {
return true;
}
}
//$e可以随便写,他是一个对象,可以打印下看看
try {
var_dump(t1());
} catch(Exception $e) {
echo '文件:' , $e->getFile() , '<br />';
echo '出错行:' , $e->getLine() , '<br />';
echo '错误信息' , $e->getMessage() , '<br />';
}
13. 命名空间
多人开发时,函数名很容易重复,引入匿名空间可以解决 namespace 的声明不许再可执行代码之前
namespace 声明后,其后的类,函数,都被封锁到命名空间中
require/include其他带有命名空间的页面,自身的空间并没有被影响
//test.php
<?php
namespace zixueit;
class Mysqli {
public $test = 'my-mysqli';
}
//test1.php
require('./test.php');
//下面方法是错误的
//print_r(new Mysqli());
//可以访问两种效果是一样的
print_r(new \zixueit\Mysqli());
use \zixueit\Mysqli;
print_r(new Mysqli());
//输出:zixueit\Mysqli Object ( [test] => my-mysqli
)
//当两个文件的类名一样时,可以给引入的取个别名
use \zixueit\Mysqli as a;
print_r(new a());//输出结果也一样
14. 延迟绑定
class Par {
public static function who() {
echo 'Par ~~~';
}
public static function test() {
echo self::who();
}
}
class Son extends Par {
public static function who() {
echo 'Son ~~~';
}
}
Son::test(); // Par ~~~
当继承父类时,因为子类test方法访问的是self,为本类(父类)的who方法,所以子类继承之后会访问父类的who,想要访问子类自己的who,则如下修改:
class Par {
public static function who() {
echo 'Par ~~~';
}
public static function test() {
//此时,哪个类对用test方法,static就是那个对象
echo static::who();
}
}
class Son extends Par {
public static function who() {
echo 'Son ~~~';
}
}
Son::test(); // Son ~~~
15. 超载的static(static的使用)
- 函数内声明静态变量用(声明之后下次访问会保留上次的值)
function t() {
static $age = 1;
$age +=1;
echo $age , '<br />';
}
t();//2
t();//3
- 声明类的静态属性和静态方法时用
class Human {
public static $leg = 99;
public static function cry() {
echo '55';
}
}
echo Human::$leg , '<br />';
- 延迟绑定
class Par {
public static function Model() {
echo __CLASS__ , '<br />';
echo get_called_class() , '<br />';
}
//下面这个static::,会把调用Model的上下文切换运行时的调用类,而非定义时
public static function save() {
static::Model();
}
}
class Son extends Par {
public static function Model() {
echo __CLASS__ , '<br />';
echo get_called_class() , '<br />';
}
}
Son::save(); // Son,Son