php面向对象开发学习笔记

面向对象程序设计（英语：Object-oriented programming，缩写：OOP），指一种程序设计范型，同时也是一种程序开发的方法。对象指的是类的集合。它将对象作为程序的基本单元，将程序和数据封装其中，以提高软件的重用性、灵活性和扩展性

1.在定义对象方法的时候，虽然不用在前面写public默认为公共方法，但是建议写上。

php面向对象第一天

1.什么是面向对象？

要素：抽象性，封装性，共享性，强调对象结构而不是程序结构。

什么是类？

可以理解成一个功能集合菜单，我们通过类来实现生成我们的方法。

例：一台电脑

类：显示器/键盘/主机...的集合（封装）。

对象：显示器/键盘/主机……其中之一，拥有自己的独有功能。

属性：电脑。

方法：提高功能，看电影，玩游戏，编程，上网……。

2.使用class创建一个类

有了类才能有方法。

格式：

1. class 方法名 { 
2. ...... 
3. } 

成员属性：自定义变量（一个名而已）。

成员方法：自定义功能。

3.类的成员属性和成员方法

注意：使用public来定义成员属性不要用var。

实例代码如下:

1. class MyPc { //声明一个类，定义一个方法MyPc。 
2. public $name; //成员属性。 
3. var $price; //成员属性 
4. function vod() { //成员方法，实现返回字符串功能。 
5. return "test"; 
6. } 
7. } 

4.使用new函数对象实例化

格式：new 对象名(参数)

实例1代码如下:

1. class MyPc { //声明一个类，定义一个方法MyPc。 
2. public $name; //成员属性。 
3. var $price; //成员属性 
4. function vod() { //成员方法，实现返回字符串功能。 
5. return "test"; 
6. } 
7. } 
8. $pc1 = new Mypc(); //实例化 
9. $pc1 -> name; 

实例2代码如下:

2. class MyPc { 
3.  var $key; 
4.  public $name; 
5.  function vod() { 
6.   echo "hello"; 
7.  } 
8. } 
9. $pc1 = new MyPc(); 
10. $pc1->key = "10101010"; 
11. echo $pc1->key; 
12. ?> 

php面向对象第二天

1.创建一个和多个对象。

2.对象中的 $this 关键字。

3.初始化对象 __construct()

4.析构函数 __destruct()

1.创建一个和多个对象

创建一个和多个对象我们只需要多次使用 new 函数，对类进行实例化。

实例代码如下:

1. class MyPc { 
2. public $name; 
3. public $price; 
4. function vod() { 
5. return "播放电影"; 
6. } 
7. .... 
8. } 
9. $pc1 = new MyPc(); 
10. $pc2 = new MyPc(); 
11. $pc3 = new MyPc(); 

2.对象中的 $this 关键字

$this 关键字是用来访问当前对象中的对象属性和对象方法的系统变量。

范围：该类当中。

实例代码如下:

1. class MyPc { 
2. public $name;-------- 
3. public $price;      | 
4.                     | 
5. function vod() {    | 
6. $this->name;<-------- 
7. } 
8. .... 
9. $this->vod(); //这样输出调用的就是 public $name; 
10. .... 
11. } 

实例2代码如下:

2. class MyPc { 
3.  public $name; 
4.  function vod() { 
5.   return $this->name . " 正在播放 未来战警"; 
6.  } 
7.  function game() { 
8.   return $this->vod() . " 正在运行 魔兽世界"; 
9.  } 
10. } 
11. $pc1 = new MyPc(); 
12. $pc2 = new MyPc(); 
13. $pc1->name = "1号计算机"; 
14. $pc2->name = "2号计算机"; 
15. echo $pc1->vod() . ""; 
16. echo $pc2->game() . ""; 
17. ?> 

3.初始化对象 __construct()

初始化相当于就是预先预定好某个成员属性的初始值。

格式：

1. class MyPc { 
2. function __construct() { 
3. 初始化操作 
4. } 
5. } 

实例代码如下:

2. class MyPc { 
3.  public $name; 
4.  function __construct($name = "") { //初始化。 
5.   $this->name = $name; //把初始化内容第四行的 $name = "" 赋值给 $this 取到的第三行的 public $name;。 
6.  } 
7.  function vod() { 
8.   return $this->name . " 正在播放 未来战警"; 
9.  } 
10.  function game() { 
11.   return $this->vod() . " 正在运行 魔兽世界"; 
12.  } 
13. } 
14. $pc1 = new MyPc("1号计算机"); //这里进行初始化。 
15. $pc2 = new MyPc("2号计算机"); 
16. echo $pc1->vod() . ""; 
17. echo $pc2->game() . ""; 
18. ?> 

4.析构函数 __destruct()

能够在对象释放时自动被调用的方法，被成为析构函数，也能理解为垃圾回收机制。

规则：后进先出，先实例化后释放，最后实例化调用，最先释放,最后被调用。

实例代码如下:

2. class MyPc { 
3.  public $name; 
4.  function __construct($name = "") { 
5.   $this->name = $name; 
6.  } 
7.  function vod() { 
8.   return $this->name . " 正在播放 未来战警"; 
9.  } 
10.  function game() { 
11.   return $this->vod() . " 正在运行 魔兽世界"; 
12.  } 
13.  function __destruct() { //后进先出。 
14.   echo "垃圾回收机制：" . $this->name . ""; 
15.  } 
16. } 
17. $pc1 = new MyPc("1号计算机"); 
18. $pc2 = new MyPc("2号计算机"); 
19. echo $pc1->vod() . ""; 
20. // $pc1 = null; //这里是当特殊需要执行完毕立即回收内存的话，可以使用null。 
21. echo $pc2->game() . ""; 
22. ?> 

php面向对象第三天

类的封装和应用

1.封装关键字：public , protected , private。

2.封装相关函数：__set() , __get()。

1.封装关键字：public , protected , private

封装是把一些相关的属性和行为隐藏起来，从而得到保护和安全。

封装关键字

public：表示全局，类内部外部子类都可以访问。

protected：表示受保护的，只有本类或子类或父类中可以访问。

private：表示私有的，只有本类内部可以使用。[重要：这个关键字在使用时，调用私有属性或方法，只能在本类调用，感觉就像多一道工序，做一个跳板。详见实例2]

       public     protected     private

 全局     1           0            0

继承类    1           1            0

 本类     1           1            1

实例代码如下:

2. class MyPc { 
3.  public $name; //公共属性 
4.  protected $price; //保护属性 
5.  private function vod() { //私有属性 
6.   $this->name; 
7.  } 
8.   . . . 
9.  } 
10. ?> 

实例2代码如下:

2. class MyPc { 
3.  private $name; 
4.  function __construct($name = "") { 
5.   return $this->name = $name; 
6.  } 
7.  private function open() { 
8.   return $this->name . "---打开电源，正在开机"; 
9.  } 
10.  public function ok() { 
11.   return $this->open() . "---OK"; 
12.  } 
13. } 
14. $pc = new MyPc("我的电脑"); 
15. echo $pc->ok(); 
16. ?> 

分装相关函数： __set() , __get() 作用：操作私有属性或方法。

__set()：取得当前类中封装过的私有属性或私有方法，重新执行或赋值操作。

格式：__set($n,$v)

__get()：取得（间接访问防止裸输出）当前类中封装过的属性或方法并转换成公有属性。

__get/__set实例代码如下:

2. class MyPc { 
3.  private $name; 
4.  public function __construct($name = "") { 
5.   return $this->name = $name; 
6.  } 
7.  public function __get($name) { 
8.   return $this->name . "__get"; 
9.  } 
10.  public function __set($n, $v) { //$n对应对象属性$name，$v对应倒数第三行__set。 
11.   $this-> $n = $v; 
12.  } 
13.  private function open() { 
14.   return $this->name . "---打开电源，正在开机"; 
15.  } 
16.  public function ok() { 
17.   return $this->open() . "---OK"; 
18.  } 
19. } 
20. $pc = new MyPc("我的电脑"); 
21. $pc->name = "__set"; 
22. echo $pc->name; 
23. ?> 

类的继承和应用

1.继承关键字：extends。

2.PHP继承的规则。

3.基类方法重载和基类方法访问。

1.继承关键字：extends

PHP类的继承，我们可以理解成共享被继承类（基类）的类容。

2.格式,代码如下:

1. class MyPc { 
2. ... 
3. } 
4. class Home extends MyPc { 
5. ... 
6. } 

3.基类方法重载和基类方法访问

格式：基类名::原始基类方法名称

4.实例

继承,代码如下:

2. class Root { 
3.  public function print1() { 
4.   return "Root_print"; 
5.  } 
6. } 
7. class Son extends Root { 
8.  public function print2() { 
9.   return "Son_print"; 
10.  } 
11. } 
12. $p = new Son(); 
13. echo $p->print1(); 
14. ?> 

重载,如果基类的某个方法需要在派生类中加强，那么可以用重载功能,代码如下:

2. class Root { 
3.  public function print1() { 
4.   return "Root_print"; 
5.  } 
6. } 
7. class Son extends Root { 
8.  public function print1() { 
9.   return Root :: print1() . "Son_print"; 
10.  } 
11. } 
12. $p = new Son(); 
13. echo $p->print1(); 
14. ?> 

类的抽象方法和类

其实也可以理解为，这是一个规范。在类的开头定义一个抽象类和方法，然后在下面的类继承抽象类，这样可以强制规范以下派生类的方法命名（就只是在抽象类中定义的抽象方法名，还可自己增加，但是主要的不能修改）。

1.抽象关键字：abstract。

2.抽象方法和抽象类的定义。

3.抽象类和方法使用规则。

1.抽象关键字:abstract

抽象就是无法确切的说明，但又有一定的概念或者名称。

2.抽象方法和抽象类的定义

一个类至少有一个方法是抽象的,我们称之为抽象类,所以如果定义抽象类首先定义抽象方法。

格式：

1. abstract class class1 { 
2. abstract function fun1(); 
3. ... 
4. } 

注意：1.类中至少有一个抽象方法。；2.抽象方法不允许有{}。；3.抽象方法前面必须加 abstract 。

3.抽象类和方法使用规则

抽象类特点：

1.不能被实例化，只能被继承。

2.继承的派生类当中要把所有抽象方法重载才能被实例化。

格式（不可以实例化）：

1. abstract class cl1 { 
2. abstract function fun1(); 
3. ... 
4. } 

格式（可以实例化）：

1. class cl2 extends cl1 { 
2. function fun1() { //重载抽象方法 
3. } 
4. ... 
5. } 

实例代码如下:

2. abstract class ChouXiang { 
3.  abstract function fun1(); 
4. } 
5. class PaiShengLei extends ChouXiang { 
6.  public function fun1() { //重载 
7.   echo "test"; 
8.  } 
9. } 
10. $p = new PaiShengLei(); 
11. $p->fun1(); 
12. ?>