php面向对象教学笔记,php 面向对象笔记

===================================================

PHP的面向对象：

对象是客观存在的一个实体。

类是对对象抽象的一个描述。

概念：对象(实体)、类、 类与对象的关系。

oop面向对象编程的特点：封装、继承、多态

类和对象的关系：

类的实例化结果就是一个对象(使用new关键字)

对对象的抽象描述就是一个类

===================================================

一、如何定义一个类，和使用

1.1 语法格式：

[修饰符] class 类名 [extends 父类] [implements 接口1[,接口2...]]{

【成员属性】定义变量

【成员方法】定义函数

}

1.2 成员属性格式：

修饰符 $变量名[=默认值]; 如：public $name="zhangsan";

注意：成员属性不可以是带运算符的表达式、变量、方法或函数的调用。 如：

public $var3 = 1+2;

public $var4 = self::myStaticMethod();

public $var5 = $myVar;

正确定义方式：

public $var6 = 100; //普通数值(4个标量：整数、浮点数、布尔、字串)

public $var6 = myConstant; //常量

public $var7 = self::classConstant; //静态属性

public $var8 = array(true, false); //数组

常用的属性修饰符：public、protected、private、static、var

1.3 成员方法格式：

[修饰符] function 方法名(参数..){

[方法体]

[return 返回值]

}

常用的方法修饰符：public、protected、private、static、abstract、final

1.4 对象：类的实例化就会产生一个对象。

如： $p = new Person();

1.5 $this 关键字： 表示自己，表示当前使用对象，*哪个对象调用代表哪个

1.我们在类中调用自己的成员属性或方法都是使用 $this->调用。

2.注意：静态方法不可以使用$this关键字

===================================================

二、构造方法和析构方法

2.1. 构造方法：

1.当我们通过new关键字来创建一个对象时，第一个自动执行的方法称为构造方法。

2.方法名__construct(); 主要用于初始化对象。

(在php4.0时可使用与类名重名的方法作为构造方法)

2.2. 析构方法：当这个对象被销毁时最后自动调用的方法,称为析构方法。

1.__destruct(); 目的是释放资源(如关闭连接、文件，释放资源)

2.对象被销毁时最后自动调用

===================================================

三、封装(访问控制)

3.1 封装：就是将"属性" private或protected 私有，并提供公有的setter放置与getter取值方法

public(公有) protected(受保护) private(私有)

===========================================================

在本类中 Y Y Y

在家族中 Y Y N

在类外边 Y N N

public 类外需要调用此类内的方法或属性时使用

protected 类外不需要调用，而家族内需要使用

private 用于安全信息，只用于当前类

===================================================

四、 重载

4.1 属性重载中的四个魔术方法：__set() __get() __isset() __unset()

__get()：当我们直接输出一个对象中的非公有属性时会自动调用的方法，

并将属性名以第一个参数传进去。

__get($name){...} //外部：$m->priAge;

__set()：当我们直接设置一个对象中的非公有属性时会自动调用的方法，

并将属性名以第一个参数，值作为第二参数传进去。

__set($name,$value){...} //外部：$m->priAge = 100;

__isset()：验证一个对象属性isset($this->name) 或 empty($this->name)时, $this->name是一个非公有属性时，自动调用此方法。

public function __isset($param){

return isset($this->$param);

}

__unset()当销毁一个对象属性unset($this->name), $this->name是一个非公有属性时，自动调用此方法。

public function __unset($param){

unset($this->$param);

}

4.2 方法的重载:

mixed __call ( string $name , array $arguments )

mixed __callStatic ( string $name , array $arguments ) php5.3.0支持

1.当调用一个不可访问方法(如未定义，或者不可见)时，__call() 会被调用。

2.当在静态方法中调用一个不可访问方法(如未定义，或者不可见)时，__callStatic() 会被调用。

第一个参数表示方法名，第二参数表示调用时的参数列表(数组类型)

class A {

//调用不存在的方法

public function __call($methodName,$args) {

echo $methodName;

print_r($args);

}

//调用不存在的静态方法

static public function __callStatic($methodName,$args) {

echo '

'.$methodName;

print_r($args);

}

}

$a = new A;

$a->say('a','b');

A::test('c','d');

===================================================

五、 继承

5.1 继承：extends

*继承的目的：为了减少重复的代码。

假如Ｂ类继承Ａ类，那么就继承了Ａ中所有非私有属性和方法.其中Ａ叫父类(基类)Ｂ叫子类(派生类)。

class B extends A{

....

}

1.*parent：若子类出现覆盖父类的方法，那么想调用被覆盖掉的父类方法，并可以跟子类的方法融合为一起

格式：parent::父类方法 | 父类名称::父类方法

class A{

public function __construct(){

//....

}

}

class B extends A{

public function __construct(){

parent::__construct();//注意要调用一下父类的构造方法

//....

}

}

2.继承的特性

1、PHP支持单继承,一类只能继承一个父类

2、PHP支持多层继承,可以有子孙类

3、子类会继承父类所有属性和方法,但是私有的属性和方法不能调用

3.属性的继承

1、私有的属性不会被覆盖，其他会被覆盖。

2、属性的修饰只能更加松散，不能更加严谨。 松散性：public > protected > private

3、如果子类中有与父类同名的属性，父类有public $name 子类只能使用public修饰

3、如果子类中有与父类同名的属性，父类有protected $name 子类能使用protected,public修饰

4.方法的继承

1、所有方法可以被继承，但是私有的方法不能被使用

2、如果子类有与父类同名的方法，那么除了私有的方法，其他都被覆盖掉。

3、如果子类有与父类同名的方法，方法的修饰只能更加松散，不能更严谨。

===================================================

六、 final、static和const

*内存逻辑上：常量区(常量、静态属性)、代码区(类、函数)、栈内存(普通的小的变量)、堆内存(大的变量)

6.1 final关键字：主要用于修饰类与成员方法

目的：一是为了安全，二是没有必要

1.使用final关键字修饰类，表示这个类不能被继承，防止有子类的覆盖

2.使用final关键字修饰的方法，不可以在子类中被覆盖(重写)。

3.使用final关键字不能修饰属性

final class B {

final public function A {

..

}

}

---------------------------------------------------------------

6.2 static关键字：表示静态的意思，用于修饰类的属性和方法

static关键字修饰 属性/方法 称为 静态属性/静态方法，

注意：静态方法在实例化后的对象不可以访问 //$对象名->静态方法名

1.可以不用new(实例化)就可以直接使用方法或属性

*外部调用：类名::方法名 | 类名::属性名

*类中调用：self::静态属性名 | self::静态方法名

*2.静态属性是共享的。也就是调用多个对象也是指向同一个地址

3.在静态方法中不可以使用非静态的内容。就是不让使用$this

4.在一个类的方法中若没有出现$this的调用，默认此方法为静态方法。

5.static不能修饰类

---------------------------------------------------------------

6.21 设计模式。目的：节省资源

1、单例设计模式 2、工厂设计模式 3、 抽象工厂设计模式

class Single

{

//定义一个静态属性，用来存放对象

static private $obj = null;

//私有化构造方法。不能在类的外部实例化对象

private function __construct() {}

//实例化对象

static public function test() {

//如果没有对象，我们就允许它new一个对象

if(!self::$obj) {

self::$obj = new Single();//创建对象

}

//有了对象，就直接返回之前的对象

return self::$obj;

}

//单例不允许克隆

public function __clone() {

trigger_error('错误', E_USER_ERROR);

}

}

$s1 = Single::test(); var_dump($s1);

$s2 = Single::test(); var_dump($s2); //调用同一个对象

$s3 = clone $s2; //报错

---------------------------------------------------------------

6.3. const关键字： 在类中修饰成员属性，将其定义成常量(不可修改的)，

1.一般要求常量名都是大写的,没有“$”符 没有其他修饰符(public)

2.定义格式：const 成员常量名="值";

3.使用：

*外部调用：类名::成员常量名;

*类中调用：self::成员常量名;

---------------------------------------------------------------

6.4. 检测当前对象是属于谁的类(家族类也是)

1.instanceof 用于确定一个 PHP 变量是否属于某一类 class 的实例：

class A {}

class B extends A {}

$b = new B;

if($b instanceof A) {echo 'y';}

2.is_a — 如果对象属于该类或该类是此对象的父类则返回 TRUE

===================================================

七、 类型约束

1. 类型约束可以使用的类型是：数组，对象，回调函数。

若指定的一个类名，那么可传入本类及子类的对象进去。

可以使用的约束类型：(复合类型)数组array，类名、抽象类名、接口名

class MyClass

{

//第一个参数必须为类OtherClass的一个对象

public function test(OtherClass $otherclass) {

**可以传入别的类，调用别的类的方法和属性

echo $otherclass->var;

//同这里

if( $otherclass instanceof Hanzi){

$otherclass->qinqin();

}

}

//第一个参数必须为数组

public function test_array(array $input_array) {

print_r($input_array);

}

}

===================================================

八、其他魔术方法：

1. 对象复制clone 克隆一个对象，因为对象属于引用类型，普通的“=”号属于引用赋值，

所有需要clone来复制一份。

魔术方法：__clone() 当执行clone克隆时会自动调用的方法。

class A {

public function __clone() {

//自动执行

}

}

$a = new A;

$b = clone $a; //克隆，是两个对象

-----------------------------------------------------------------

2. __toString()方法：魔术方法，当我们直接要输出一个对象时，如echo $a,print $a，

那么会自动调用的方法。

注意：__toString()方法必须返回一个字串类型的值。

class A {

public function __toString() {

return '这是一个对象，不允许ehco,print...';

}

}

$a = new A;

echo $a; //报错

-----------------------------------------------------------------

3. *自动加载"类函数"__autoload(类名):

当new 实例化一个对象时，这个类若不存在，则自动调用此函数，并将类名存入参数

我可以使用这个实现类的自动加载。

function __autoload($className) {

include './autoload/'.$className.'.class.php';

}

$a = new A;

$a->say(); //say

//在 autoload/A.class.php下

class A{

public function say() {

echo 'say';

}

}

-----------------------------------------------------------------

4. __invoke把对象当成函数使用的时候自动调用

class A {

public function __invoke() {

echo 'aa';

}

}

$a = new A;

$a(); //aa

===================================================

九、 对象序列化(串行化)(webservice XML)(在对象持久化存储、和传输中使用)

serialize() -- 序列化

unserialize() -- 反序列化

1.php里面的值都可以使用函数serialize()来返回一个包含字节流的字符串来表示。

2.unserialize()函数能够重新把字符串变回php原来的值。

3.序列化一个对象将会保存对象的所有变量，但是不会保存对象的方法，只会保存类的名字。

1.__sleep(): 是执行串行化时自动调用的方法，目的是实现资源类型的属性的关闭操作。

@@sleep方法需要返回一个数组，其中数组中的值是序列化时要保留的属性名

2.__wakeup():是在执行反串行化时自动调用的方法，目的是实现资源属性的打开(sleep方法关闭的资源)

//实例：

class A {

public $name1 = 'xiaohei';

public $name2 = 'xiaobai';

public function demo() {

return 'aa';

}

//序列化自动调用的方法

public function __sleep() {

return array('name2'); //只想存储name2，就返回name2

}

//反序列化自动调用的方法

public function __wakeup() {

echo '###';

}

}

$a = new A;

//序列化

$data = serialize($a);

//存入文件

file_put_contents('./1.txt', $data);

//获得数据

$str = file_get_contents('./1.txt');

echo $str; //O:1:"A":1:{s:4:"name";s:7:"xiaohei";}

//反序列化

$tmp = unserialize($str);

print_r($tmp); //A Object ( [name] => xiaohei )

-------------------------------------------------------------------------------------

JSON格式的字符串进行编码/解码

json_encode：对变量进行 JSON 编码

json_decode：对 JSON 格式的字符串进行编码

$arr = array('id'=>1, 'name'=>'jack');

$str1 = json_encode($arr);

echo $str1; //{"id":1,"name":"jack"}

$a = json_decode($str1, true); //加true返回array，否则返回object

echo $a; //Array ( [id] => 1 [name] => jack )

===================================================

十、 抽象类：

目的：抽象类对于子类(实现类)，有一个约束的作用，

特点：

//1.定义抽象类

abstract class A {

//2.定义抽象方法

abstract public function test1();

abstract public function test2();

//3.可以有普通方法和属性,不需要子级实现

public function demo() {}

public $name = 'aa';

//4.不能定义抽象属性 Fatal error

abstract public $age = 18;

}

class B extends A {

//5.@@继承了抽象类的"普通类"必须实现抽象类的"所有抽象方法"

public function test1() {}

public function test2() {}

//6.包含了抽象方法的类必须是抽象类，Fatal error

abstract function test3() {}

}

abstract class C extends A {

//7.不能覆盖抽象方法，Fatal error

abstract public function test1() {}

//8.可以继承抽象类的同时添加抽象方法

abstract public function test3();

}

//8.不能实例化，Fatal error

$c = new C;

===================================================

十一、 接口:

目的：同抽象类相同,是更具体的抽象类

假如一个抽象类中所有的方法都是抽象的，那么我们可以使用另外一种方式定义：接口

接口使用关键字interface来定义，接口中只能有常量与抽象方法。

//1.定义接口

interface A {

//2.接口不能有普通属性，Fatal error

public $name = 'aa';

//3.接口不能有普通方法，Fatal error

public function test() {}

//3.但可以定义常量

const HOST = 'aa';

//4.定义接口方法，不需要abstract

public function test1();

}

interface B {

//5.接口之间是继承关系，重复定义Fatal error

const HOST = 'bb';

public function test2();

}

class C {}

//6.可以同时继承"单"类、实现"多"接口(先继承，后实现)

class D extends C implements A,B {

//7.@@继承了抽象类的"普通类"必须实现抽象类的"所有抽象方法"

public function test1() {}

public function test2() {}

}

抽象类和接口总结：

1.目的：制定规范，为了限制其子类

2.选择：如果规范中需要有"普通方法"就选择抽象类

3.区别：

1.定义关键字不同。抽象类：abstract 接口：interface

2.继承/实现关键字不同。抽象类：extends 接口：implements

3.抽象类可以有普通方法，接口不能有普通方法

4.抽象类只能被单继承，接口可以多实现

5.接口不能有成员属性，只有常量与抽象方法

===================================================

十二、多态

定义：对于“同一个方法”，传入“不同对象”，实现了不同的效果

class Meizi {

public function meet($obj) {

//限制了对象必须有qinqin()这个方法

if( $obj instanceof Hanzi){

//同一个方法

$obj->qinqin();

}else{

echo '你不会亲亲这个功能！';

}

}

}

//抽象类

abstract class Hanzi

{

abstract public function qinqin();

}

//大屌丝类

class DDS extends Hanzi {

public function qinqin() {

echo '被妹子打了一巴掌，这就是DDS的命运';

}

}

//高富帅类

class GFS extends Hanzi {

public function qinqin() {

echo '不仅仅亲亲，还啪啪啪，这是高富帅的命运';

}

}

//萌妹子类

class MengMeizi {}

$m = new Meizi;

$dds = new DDS;

$gfs = new GFS;

$mmz = new MengMeizi;

//传入对象

echo $m->meet($dds); //实现了DDS的效果

echo $m->meet($gfs); //实现了GFS的效果

//没有限制

echo $m->meet($mmz); //你不会亲亲！

@@多态的两个实例：

./1.通过接口实现多态的应用.php

./2.通过普通类实现多态的应用.php

===================================================

十三、异常处理：

在php5中有一种新的错误处理机制--异常处理：(采用面向对象方式的)

涉及的类：Exception异常类

Exception类结构：

class Exception

{

protected $message = 'Unknown exception'; // 异常信息

protected $code = 0; // 用户自定义异常代码

protected $file; // 发生异常的文件名

protected $line; // 发生异常的代码行号

function __construct($message = null, $code = 0);

final function getMessage(); // 返回异常信息

final function getCode(); // 返回异常代码

final function getFile(); // 返回发生异常的文件名

final function getLine(); // 返回发生异常的代码行号

final function getTrace(); // backtrace() 数组

final function getTraceAsString(); // 已格成化成字符串的 getTrace() 信息

/* 可重载的方法 */

function __toString(); // 可输出的字符串

}

使用：

try{

throw new Exception("年龄不可以为负数"); //异常抛出

}catch(Exception $e){

//异常处理

echo $e->getmessage();

}

实例：

function addUser($username) {

if($username="xiaobai") {

//添加成功

}else {

//添加失败

throw new Exception('添加失败');

}

}

function updateUser($username) {

if($username = "xiaohei") {

//修改成功

}else {

//修改失败

throw new Exception('修改失败');

}

}

try {

addUser('xiaobaia');

updateUser('xiaohei');

}catch(Exception $e) {

echo '失败信息是：'.$e->getMessage();

}

@@当捕获到一个异常后，try()块里面的后续代码不继续执行

本文原创发布php中文网，转载请注明出处，感谢您的尊重！