类的知识点

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.'
';
    }
    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).'
';
    }
}
class Son extends Par {
    public function __construct() {
        //ThinkPHP 注意
        parent::__construct();
        echo '1'.'
';
    }
}

7. 魔术方法

__construct(): 构造方法，new实例化时，自动调用
__destruct(): 析构方法，对象摧毁时自动调用
__get(属性名):当读取对象的一个不可见属性时，自动调用，并返回值
不可见：未定义或者无权访问时
__set(属性名，属性值):当对一个不可见的属性赋值时，自动调用
__isset(属性名) : 当用isset,或者empty判断一个不可见的属性时，自动调用
__unset(属性名): 当unset一个不可见属性时，自动调用

';
        return 3;
    }
    public function __set($per , $value) {
        echo 'you want to set my ' ,$per ,' to ' , $value , '
';
    }
    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 , '
';
        echo '但设不设置看我的心情
';
    }
}
$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() , '
';
    echo '出错行:' , $e->getLine() , '
';
    echo '错误信息' , $e->getMessage() , '
';
}

13. 命名空间

多人开发时，函数名很容易重复，引入匿名空间可以解决 namespace 的声明不许再可执行代码之前
namespace 声明后，其后的类，函数，都被封锁到命名空间中
require/include其他带有命名空间的页面，自身的空间并没有被影响

//test.php
 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 , '
';
}
t();//2
t();//3

声明类的静态属性和静态方法时用

class Human {
    public static $leg = 99;
    public static function cry() {
        echo '55';
    }
}
echo Human::$leg , '
';

延迟绑定

class Par {
    public static function Model() {
        echo __CLASS__ , '
';
        echo get_called_class() , '
';
    }
    //下面这个static::，会把调用Model的上下文切换运行时的调用类，而非定义时
 public static function save() {
        static::Model();
        }
}
class Son extends Par {
    public static function Model() {
        echo __CLASS__ , '
';
        echo get_called_class() , '
';
    }
}
Son::save(); // Son,Son

类的知识点

1.final类和final

2. 三种权限讲解

3. 静态属性和方法（static）

4. 类常量（const）

5. 单例模式

6. self与parent

7. 魔术方法

8. 魔术方法的作用

9. 自动加载

10. 抽象类

11. 接口的概念

12. 错误异常（一般在不该出错的时候用，如 连接数据库）

13. 命名空间

14. 延迟绑定

15. 超载的static(static的使用)

你可能感兴趣的:(类的知识点)

12. 错误异常（一般在不该出错的时候用，如连接数据库）