PHP面向对象_php new 一个类的时候携带参数

类的定义

类的定义语法格式：

class 类名{
成员属性；
成员方法；
}
1
2
3
4

定义一个类

<?php
class person {
    public $name;
    public $age;
    public function speak() {
        echo 'hello,everybody,my name is'.$this->name.'and i am'.$this->age.'now。<br>';
    }
}
?>
1
2
3
4
5
6
7
8
9

对象的创建

$对象名=new  类名 （[参数1，参数2...]）;
1

• new 表示创造一个新的对象
• 对象创建成功，就可以通过 对象->成员 来访问类中的成员
• 若不需要传递参数，可省略类名后面的括号

<?php
class person {
    public $name;
    public $age;
    public function speak() {
        echo 'hello,everybody,my name is '.$this->name.' and i am '.$this->age.' now。<br>';
    }
}
$p1=new person();
$p1->name="pipasound";
$p1->age="18";
$p1->speak();
?>
1
2
3
4
5
6
7
8
9
10
11
12
13

hello,everybody,my name is pipasound and i am 18 now。
1

类的封装

例如在为age赋值时，由于没有限制，因此可以赋予任何值，甚至一个负数。显然不合实际。
所以要为成员变量的访问做出一些限制，防止随意访问，即实现类的封装

用private将类的属性私有化

通过getXxx()和setXxx()方法访问私有属性

• getXxx() 获取属性值
• setXxx() 设置属性值

<?php
class Person {
    private $name;
    private $age;
    public function getName() {
        return $this->name;
    }
    public function setName($value)
    {
        $this->name=$value;
    }
    public function getAge() {
        return $this->age;
    }
    public function setAge($value) {
        if($value<0){
            echo '年龄不合法<br>';
        }else{
            $this->age=$value;
        }
    }
}
$p1=new Person();
$p1->setName("pipasound");
$p1->setAge("-18");
echo 'hello everybody,my name is '.$p1->getName().'<br>';
echo ' i am '.$p1->getAge().' now。';
?>
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

自动调用__set()方法为属性赋值
自动调用__set()方法为属性赋值
自动调用__get()方法获取属性值
hello everybody,my name is pipasound
自动调用__get()方法获取属性值
i am 18 now。
1
2
3
4
5
6

通过__get()和__set()方法访问私有属性

• __get() 获取私有成员属性的属性值
• __set() 为私有成员属性赋值

<?php
class Person {
    private $name;
    private $age;
    //定义__get()方法用于获取Person属性的值
    public function __get($property_name) 
    {
        echo '自动调用__get()方法获取属性值<br>';
        if(isset($this->$property_name)){
            return ($this->$property_name);
        }else{
            return(NULL);
        }
    }
    //定义__set()方法用于设置Person属性
    public function __set($property_name,$value)
    {
        echo '自动调用__set()方法为属性赋值<br>';
        $this->$property_name=$value;
    }
}
$p1=new Person();
$p1->name="pipasound";
$p1->age=18;
echo 'hello everybody,my name is '.$p1->name.'<br>';
echo ' i am '.$p1->age.' now。';
?>
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

• public:公有修饰符，所有外部成员都可以访问这个类的成员
• private:私有修饰符，外部代码无法访问
• protected:保护成员修饰符，外部代码无法访问，但是该类的子类可以对其访问，读写

特殊的$this

$this->属性名
1

<?php
class person {
    public $name;
    public $age;
    public function speak() {
        echo 'hello,everybody,my name is '.$this->name.' and i am '.$this->age.' now。<br>';
    }
}
$p1=new person();
$p1->name="pipasound";
$p1->age="18";
$p1->speak();
$p2=new person();
$p2->name="hello";
$p2->age="19";
$p2->speak();
?>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

hello,everybody,my name is pipasound and i am 18 now。
hello,everybody,my name is hello and i am 19 now。
1
2

构造方法

之前我们实例化一个类的对象后，才可以访问对象的属性。那我们想要在实例化对象的同时就为这个对象的属性赋值，需要通过构造方法来实现
语法格式：

修饰符 function __construct(参数列表){
 //初始化操作
}
1
2
3

<?php
 class Person{
     public $name;
     public $age;
     //声明一个构造方法，将来创建对象时，为对象的成员属性赋予初始值
     function __construct($name,$age){
         $this->name=$name;
         $this->age=$age;
     }
     function show() {
         echo $this->name.' is '.$this->age.' now.';
     }
 }
 $p1=new Person('pipasound',18);
 $p1->show();
?>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

pipasound is 18 now.
1

析构方法

在对象销毁前会自动调用，用于释放内存

function__destruct() {
  //清理操作
}
1
2
3

<?php
 class Person{
     
    public function show() {
        echo '大家好,我Person类的对象<br>';
     }
     //声明析构方法，在对象销毁前自动调用
    function __destruct(){
         echo '对象被销毁';
     }
 }
 $p1=new Person();
 $p1->show();
?>
1
2
3
4
5
6
7
8
9
10
11
12
13
14

大家好,我Person类的对象
对象被销毁
1
2

类常量

常量的值不会改变。类常量在定义时需要用const关键字来声明

<?php
 class Person{
    const PI=3.1415926;
    public function show(){
        echo Person :: PI.'<br>';//通过类名访问
    }
    public function display(){
        echo self::PI.'<br>';//通过self关键字访问
    }
}
echo Person::PI.'<br>';//在内部直接访问
$p1=new Person();
$p1->show();
$p1->display();
?>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

类中声明的常量PI是属于类本身而非对象。需要使用范围解析操作符（::）来连接类名和类常量来访问

静态成员

被static关键字修饰，不属于任何对象，只属于类

静态属性

当我们希望某些特定数据在内存中只有一份，并且可以被类的实例对象所共享，可以用静态属性

<?php
 class Student{
    public static $SchoolName="传智播客";
    public function show(){
        echo '我们的学校是：'.self::$SchoolName.'<br>';
    }
}
$p1=new Student();
$p1->show();
?>
1
2
3
4
5
6
7
8
9
10

静态方法

不创建对象就可以调用某个方法

<?php
 class Student{
    public static $SchoolName="传智播客";
    public static function show(){
        echo '我们的学校是：'.self::$SchoolName.'<br>';
    }
}
Student::show();
?>
1
2
3
4
5
6
7
8
9

在第三行定义一个静态属性schoolName,再定义了静态方法来输出学生所在学校的名称。在第八行代码通过‘类名::方法名’调用Student的静态方法，在静态方法中访问量静态属性$SchoolName.

• 通常情况下静态方法用来操作静态属性
• 在静态方法中，不要使用$this。因为静态属性是属于类的，$this则是指对象上下文。