php oop关键字,OOP面向对象基础-关键字

final

用于修饰方法和类,不能修饰属性

特点:

1. final修饰的类不能被继承

2. 用final 修饰的方法不能被覆盖重写==

应用:

登录时,账号密码的验证

static 静态

定义:用于修饰属性和方法, 不能修饰类

修饰的属性:静态属性 只能使用静态方式去访问, 在类的外面调用 类名::$属性名 内部 self::$属性名

修饰的方法:静态方法 只能使用静态方式去访问, 在类的外面调用 类名::$方法名 内部 self::$方法名

静态方法里面不能出现 $this ,静态的属性值不能修改

类中的一些方法没什么联系可以把他们设置为静态方法

实现设计模式

class Person

{

public static $name = '小小';

private static $age = '18';

public function show(){

echo self::$age;

// echo $this->name; 方法使用static后,不能使用$this

}

public function show2(){

echo self::show().",hahaha";

}

public static function show3(){

echo self::$name;

}

}

$a = new Person();

//$a ->show();

$a ->show2();

//外部调用

Person::$name;

Person::show3();

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

classPerson

{

publicstatic$name='小小';

privatestatic$age='18';

publicfunctionshow(){

echoself::$age;

//        echo $this->name;  方法使用static后,不能使用$this

}

publicfunctionshow2(){

echoself::show().",hahaha";

}

publicstaticfunctionshow3(){

echoself::$name;

}

}

$a=newPerson();

//$a ->show();

$a->show2();

//外部调用

Person::$name;

Person::show3();

单例设计模式

http://www.cnblogs.com/siqi/archive/2012/09/09/2667562.html

分析:

一个类只允许一个对象使用

先禁止生成对象

设置为静态方法

静态方法里实例化对象

判断是否存在

例子

class Demo

{

private static $obj = null;

//禁止生成对象

private function __construct()

{

}

public static function getObj(){

if(self::$obj == null){

return self::$obj = new Demo();

}else{

return self::$obj;

}

}

}

$a = Demo::getObj();

$b = Demo::getObj();

$c = Demo::getObj();

var_dump($a);

var_dump($b);

var_dump($c);

//输出结果:

// object(Demo)#1 (0) { } object(Demo)#1 (0) { } object(Demo)#1 (0) { } YES

//两个等号,判断是否是同类,三个等号,值等方面是否相同

if($a === $b){

echo "YES";

}else{

echo "NO";

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

例子

classDemo

{

privatestatic$obj=null;

//禁止生成对象

privatefunction__construct()

{

}

publicstaticfunctiongetObj(){

if(self::$obj==null){

returnself::$obj=newDemo();

}else{

returnself::$obj;

}

}

}

$a=Demo::getObj();

$b=Demo::getObj();

$c=Demo::getObj();

var_dump($a);

var_dump($b);

var_dump($c);

//输出结果:

// object(Demo)#1 (0) { } object(Demo)#1 (0) { } object(Demo)#1 (0) { } YES

//两个等号,判断是否是同类,三个等号,值等方面是否相同

if($a===$b){

echo"YES";

}else{

echo"NO";

}

const

const 常量名 = 常量值;

不能进行运算,if/循环 里面不能使用const定义常量

可以在类里面定义 ,在类的内部使用 self::常量名

可以在类里面定义 ,在类的外部使用 类名::常量名

define:不能定义再类里面定义

class Person

{

const A = 'aaaa';

public static function show(){

echo self::A;//可以在类里面定义 ,在类的内部使用 self::常量名

}

}

//Person::show();//aaaa

echo Person::A;//aaaa 可以在类里面定义 ,在类的外部使用 类名::常量名

1

2

3

4

5

6

7

8

9

10

11

classPerson

{

constA='aaaa';

publicstaticfunctionshow(){

echoself::A;//可以在类里面定义 ,在类的内部使用 self::常量名

}

}

//Person::show();//aaaa

echoPerson::A;//aaaa  可以在类里面定义 ,在类的外部使用 类名::常量名

instanceof 关键字

判断一个对象是否属于某个类 或该类的子类的实例

$c instanceof A

(实例化的对象 instanceof 类名)

class A{}

class B{}

class C extends A{}

$a = new A();

$b = new B();

$c = new C();

if($c instanceof A){

echo "YES";

}else{

echo "NO";

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

classA{}

classB{}

classCextendsA{}

$a=newA();

$b=newB();

$c=newC();

if($cinstanceofA){

echo"YES";

}else{

echo"NO";

}

clone 克隆对象

对象的引用赋值,

克隆语法 $a = clone $b;

class A

{

public $name = 'zz';

}

$a = new A;

//var_dump($a);//object(A)#1 (1) { ["name"]=> string(2) "zz" }

//$a->name = 'xx';

//$b = $a;

//var_dump($b);//object(A)#1 (1) { ["name"]=> string(2) "xx" }

//var_dump($a);//object(A)#1 (1) { ["name"]=> string(2) "xx" }

var_dump($a);

$c = clone $a;

var_dump($c);

//object(A)#1 (1) { ["name"]=> string(2) "zz" } object(A)#2 (1) { ["name"]=> string(2) "zz" }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

classA

{

public$name='zz';

}

$a=newA;

//var_dump($a);//object(A)#1 (1) { ["name"]=> string(2) "zz" }

//$a->name = 'xx';

//$b = $a;

//var_dump($b);//object(A)#1 (1) { ["name"]=> string(2) "xx" }

//var_dump($a);//object(A)#1 (1) { ["name"]=> string(2) "xx" }

var_dump($a);

$c=clone$a;

var_dump($c);

//object(A)#1 (1) { ["name"]=> string(2) "zz" } object(A)#2 (1) { ["name"]=> string(2) "zz" }

__clone魔术方法

在该对象被克隆时,自动调用

作用 :

1. 如果封装该方法,那么会使对象不能被克隆

2. 将属性里对象值,在被克隆时,也进行克隆

3. 在被克隆时候,可以重置或更改相关属性

//克隆 对象中有对象,克隆时,都增加

//object(B)#3 (1) { ["obj"]=> object(A)#4 (1) { ["name"]=> string(3) "aaa" } }

class A

{

public $name = "aaa";

}

class B

{

public $obj = null;

public function __construct($obj)

{

//实例化的时候传入一个对象

$this->obj = $obj;

}

public function __clone()

{

$this->obj = clone $this->obj;

}

}

$m = new B(new A);

var_dump($m);

$n = clone $m;

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

//克隆   对象中有对象,克隆时,都增加

//object(B)#3 (1) { ["obj"]=> object(A)#4 (1) { ["name"]=> string(3) "aaa" } }

classA

{

public$name="aaa";

}

classB

{

public$obj=null;

publicfunction__construct($obj)

{

//实例化的时候传入一个对象

$this->obj=$obj;

}

publicfunction__clone()

{

$this->obj=clone$this->obj;

}

}

$m=newB(newA);

var_dump($m);

$n=clone$m;