PHP与MySQL开发入门中

# 面向对象的概念（OOP）

1、出现软件危机（落后的软件生产力无法满足迅速增长的计算机软件需求） 2、出现软件工程学（分为结构化方法和面向对象） oop目标：重用性、灵活性、扩展性 oop特点：封装、继承、多态

认识面向对象面向对象的三个特征： 1、对象的行为：方法 2、对象的状态：属性 3、对象的标识：重新具有新的属性，标识性的

# 如何抽象一个类

格式什么的看起来太烦，直接贴个代码

<?php
/**
 * 类的声明
 */
class Person
{
    public $age;

    public function say($word)
    {
        echo "she say {$word}";
    }

    public function info()
    {
        $this->say('Hi');
        return $this->age;
    }
}
$xiaoming = new Person();
$xiaoming->age = 22;
$age = $xiaoming->info();
echo $age;
?>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# 构造方法和析构方法

<?php
/**
 * 构造方法和析构方法
 */
class Person
{
    //构造方法当new时自动执行
    public function __construct($event, $age)
    {
        $this->event = $event;
        $this->age = $age;
    }

    public function data()
    {
        return $this->age;
    }

    public function __destruct()
    {
        //对象被销毁时执行，没有代码去运行了
        //用途 可以进行资源的释放操作 数据库关闭
        echo "{$this->event} 结束<br>";
    }
}

$xiaomimg = new Person('测试1', 30);
$xiaomimg = new Person('测试2', 30);
echo $xiaomimg->data();
?>

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

# 面向对象封装性

设置私有成员与私有成员访问

魔术方法__set($key, $value) ：设置元素的时候调用（只针对protected / private）
魔术方法__get($key) ：取这个元素的时候调用
魔术方法__isset($key) ：判断元素是否设置时使用
魔术方法__unset($key) ：从类里面释放的时候调用

封装的修饰符：

public：（共有的默认）
private ：（私有的）私有的成员方法，不能在类的外部直接访问
protected ：（受保护的）私有的成员方法，不能在类的外部直接访问

<?php
/**
 * 面向对象之封装性
 */
//修饰符 public private protected
class Person
{
    public $test_unset = '测试unset';
    private $name = 'xiaoming';
    private $age = 18;
    protected $money = 10000;

    //私有的成员方法，不能在类外部直接访问
    private function getAge()
    {
        return $this->age;
    }

    //被保护的成员方法，不能在类外部直接访问
    protected function getMoney()
    {
        return $this->money;
    }

    public function userCard()
    {
        echo "name:" . $this->name . "<br>" .
            "age:" . $this->getAge() . "<br>" .
            "money:" . $this->getMoney() . "<br>";
    }

    public function __set($key, $value)
    {
        // 魔术方法set只正对private、protected有效
        if ($key == 'name' && $value == 'xiaohong') {
            echo '我监听到了set方法';
        }
    }

    public function __get($key)
    {
        if ($key == 'age') {
            echo '<br>成功获取到年龄！';

        }
    }

    public function __isset($key)
    {
        if ($key == 'age') {
            echo '<br>age被设置！';
        }
    }

    public function __unset($key)
    {
        echo $key;//无效 也是只对private protected有效
        if ($key == 'test_unset') {
            echo 'test_unset执行成功！';
        }
    }
}

$xiaoming = new Person();
//getAge() getMoney()都无法调用
$xiaoming->userCard();
//name 已经为private属性 如果不用set方法 下面这行会报错
$xiaoming->name = 'xiaohong';
//age 已经为private属性 如果不用get方法 下面这行会报错
$xiaoming->age;
isset($xiaoming->age);
//unset 干掉一个变量
unset($xiaoming->test_unset);
echo $xiaoming->test_unset;
?>

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

# 面向对象之继承和多态

在子类中允许重写（覆盖）父类的方法：（在重写跟父类同样的方法名会被覆盖）重载：可以在子类中重写父类方法的时候，使用parent::方法名，这样就可以访问到父类的方法了

使用parent访问父类中被覆盖的属性和方法 parent::construct(); parent::fun();

class Person
{
    public $name;
    private $age;//私有的 继承不过来了
    protected $money;//外部不能访问 但是可以被继承过去

    public function __construct($name, $age, $money)
    {
        $this->name = $name;
        $this->age = $age;
        $this->money = $money;
    }

    public function cardInfo($pp)
    {
        echo "name:" . $this->name . "<br>" .
            "age:" . $this->age . "<br>" .
            "money:" . $this->money . "<br>";
    }
}


class Yellow extends Person
{
    public function __construct($name, $age, $money)
    {
        parent::__construct($name, $age, $money);
    }

    public function cardInfo($pp)
    {
        parent::cardInfo($pp); // TODO: Change the autogenerated stub
        echo $pp;
    }
    //protected 外部不能访问 但是可以继承
    public function show() {
        echo $this->money;
    }
}

$test = new Yellow('xiaoming', 18, 10000);
$test->cardInfo(11);
$test->show();//10000

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
36
37
38
39
40
41
42
43

# 抽象类

1、含有抽象方法的类必须是抽象类 2、抽象类不一定非得含有抽象方法 3、抽象类可以存在普通的方法 4、抽象类不能被实例化必须由一个子类去继承并且把抽象类的抽象方法都实现了

abstract class Person
{
    public abstract function eat();
}

class Man extends Person
{
    public function eat()
    {
        echo '抽象类不能被实例化 必须由一个子类去继承 并且把抽象类的抽象方法都实现了';
    }
}

$man = new Man();
$man->eat();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 接口

1、接口声明的关键字是interface 2、接口可以声明常量也可以抽象方法 3、接口中的方法都是抽象方法不用手动的abstract的去定义 4、接口不能被实例化需要一个类去实现它 5、一个类不能继承多个类，但是一个类可以实现多个接口

interface Person
{
    //首先常量不能被修改，其次属于静态方法
    const NAME = 'xiaowang';

    public function run();

    public function eat();
}

interface study
{
    public function study();
}

class Student implements Person, study
{
    const myBelong = '<br>' . '这是一个属于自己的变量';

    public function run()
    {
        echo 'run';
    }

    public function eat()
    {
        echo 'eat';
    }

    public function study()
    {
        echo 'study';
    }

    public function test()
    {
        return self::myBelong;
    }

    public static function show()
    {
        return '<br>' . '这是一个属于自己的静态方法';
    }
}

$xiaomimng = new Student();
$xiaomimng->eat();//eat
echo "<br>" . $xiaomimng::NAME;//xianming
echo $xiaomimng->test();//这是一个属于自己的变量
echo Student::myBelong;//这是一个属于自己的变量
echo Student::show();//这是一个属于自己的静态方法

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

# 关键字

final：只能用来修饰类和方法，不能修饰成员属性 特性：使用final关键字标识的类不能被继承使用funal关键字标识的方法不能被子类覆盖（重新），是最终版本目的： 1.安全，2.没必要继承或重新

static：用于修饰类的成员属性和成员方法（即静态属性和静态方法） 类中的静态属性和方法不用实例化（new）就可以直接使用类名访问格式：类::$静态属性类::$静态方法在类的方法中，不能用this->来引用变量或静态方法，而需要用self来引用 self::$静态属性 self::$静态方法静态方法中不可以使用非静态的内容，就是不让用$this 静态属性是共享的，也就是new很多对象也是公用一个属性

单例设计模式：一个类只能有一个实例对象存在 静态属性是共享的，也就是new很多对象也是公用一个属性

instanceof ：用于检测当前对象实例是否属于某一个类或这个类的子类

PHP面向对象程序设计之魔术方法： 科隆对象 $p1 = clone $p2（克隆出来互不干扰）类中通用的方法__toString() __call()方法的应用自动加载类：（php5） php中当new实例化一个不存在的类时，则自动调用此函数__autoload()，并将类名作为参数传入此函数。可以使用这个实现类的自动加载。对象串行化（序列化） class_exists：检查类是否已定义 get_class_methods：返回由类的方法名组成的数组 get_class：返回对象的类名 get_object_vars：返回由对象属性组成的关联数组 get_parent_class：返回对象或类的父类名 is_a：如果对象属于该类或该类是此对象的父类，则返回TRUE method_exits：检查类的方法是否存在 property_exists：检查对象或类是否具有该属性

# 异常处理

系统自带的异常处理 try{ ... } catch(Exception $e) { // Exception错误类 echo "错误的文件："; echo $e -> getFile(); // 得到发生异常的文件 echo "错误的行："; echo $e -> getLine(); // 得到发生异常的行 echo "错误的代码："; echo $e -> getCode(); // 得到发生异常的代码 echo "错误信息："; echo $e -> getMessage(); // 异常信息 } 自定义异常处理 class myException extends Exception { // 继承错误类 ... } 捕捉多个异常处理

← PHP与MySQL开发入门上 PHP与MySQL开发入门下 →