类常量 instanceof 运算符 单例模式

PHP的常规常量如何声明？
define 关键词声明常量，常量名大写

1 //普通常量的定义方式
2 define('PI', 3.1415926);
3 class Ma{
4  public function test(){
5  echo PI;
6  }
7 }
8 $m = new Ma();
9 $m->test();

现在问题是这样的，因为我们的常量是全局生效，一个PHP文件中一旦声明常量，常年不变的量，本
文件任何问题均可使用。
但我们现在需要一些内部的常量，将其限定到类的内部，不予类外部的常量冲突，怎么解决？
声明类内部常量
关键词：const
调用方式也采用了静态属性和属性方法类似的写法
使用 类名::常量名

 1 //普通常量的定义方式
 2 define('PI', 3.1415926);
 3 class Ma{
 4   const PI = 3.14159265897;
 5   public function test(){
 6   echo Ma::PI;//用类似静态变量的方法调用,类名加::
 7   }}$m = new Ma();
 8 $m->test();
 9 //注意类常量和外部常量虽然名字一样，但调用的方法不一样，尽管重名，但互不影响。
10 echo Ma::PI;
11 echo PI;

 instanceof 运算符

instanceof
用于判断前面的这个对象是否是后面这个类的实例

 1 <?php
 2   class A{
 3   
 4   } $a = new A;
 5   class B{
 6   } $b = new B;
 7   
 8   class C extends A{
 9   } $c = new C;
10   
11   if($c instanceof A){
12   echo '是的';
13   }else{
14   echo '不是哦！';
15  

 单例模式

场景：多人协作开发，都需要调用mysql类进行实例化操作
A: mysql = new mysql(); 通过...
B: $db = new mysql(); 通过...
两个人代码合并到一块 mysql = new mysql();
$mysql->query();
$db = new mysql();
$db->query();
new多了,2个mysql类的实例,并且多次连接数据库
如何限制,让多人开发,无论你怎么操作,只能得到1个对象
定义：单个实例对象(只能造出一个对象）

 1 //1.普通的Single
 2 /*class Single{
 3  public $rand;
 4  public function __construct(){
 5  //给新对象加一个随机数,便于判断是否为1个对象
 6  $this->rand = mt_rand(100000,999999);
 7  }
 8 }
 9 //两个实例化
10 $a = new Single();
11 $b = new Single();
12 print_r($a);
13 print_r($b);
14 //步骤2 构造方法保护起来,封锁外部new操作
15 class Single{
16  public $rand;
17  protected public function __construct(){
18  //给新对象加一个随机数,便于判断是否为1个对象
19  $this->rand = mt_rand(100000,999999);
20  }
21 }
22 //外部不能访问了,报错了
23 $a = new Single();
24 $b = new Single();
25 print_r($a);
26 print_r($b);
27 //步骤3 在类内部实例化
28 class Single{
29  public $rand;
30   protected public function __construct(){
31   //给新对象加一个随机数,便于判断是否为1个对象
32   $this->rand = mt_rand(100000,999999);
33   } public function getIns(){
34   return new Single();
35   }}//外部不能访问了,报错了
36 $a = new Single();
37 $b = new Single();
38 print_r($a);
39 print_r($b);*/
40 //4.想办法不实例化调用方法
41 /*class Single{
42   public $rand;
43   protected function __construct(){
44   //给新对象加一个随机数,便于判断是否为1个对象
45   $this->rand = mt_rand(100000,999999);
46   } static public function getIns(){
47   return new Single();
48   }}$a = Single::getIns();
49 $b = Single::getIns();
50 print_r($a);
51 print_r($b);*/
52 //5.添加判断
53 class Single{
54   public $rand;
55   static public $ob=null;
56   protected function __construct(){
57   //给新对象加一个随机数,便于判断是否为1个对象
58   $this->rand = mt_rand(100000,999999);
59   } static public function getIns(){
60   if(Single::$ob === null){
61  Single::$ob = new Single();
62   } return Single::$ob;
63   }}var_dump(Single::getIns());
64 var_dump(Single::getIns());
65 var_dump(Single::getIns());
66 /*class Test extends Single{
67   public function __construct(){
68   var_dump(rand(10000,9999999));
69   }}new Test();*/
70 //6.搞破坏
71 final class Single{
72   public $rand;
73   static public $ob=null;
74   final protected function __construct(){
75   //给新对象加一个随机数,便于判断是否为1个对象
76   $this->rand = mt_rand(100000,999999);
77   } static public function getIns(){
78   if(Single::$ob === null){
79   Single::$ob = new Single();
80   } return Single::$ob;
81   }}var_dump(Single::getIns());
82 var_dump(Single::getIns());
83 var_dump(Single::getIns());
84 //继承重写就完蛋 加上fianl 不让它继承
85 class Test extends Single{
86   public function __construct(){
87   var_dump(rand(10000,9999999));
88      }
89 }
90 new Test();

 

转载于:https://www.cnblogs.com/zhony/p/10251852.html