创建
类使用 class 关键字后加上类名定义
咧：
初始化对象
用new
然后用var_dump()打印出来属性
咧：
1
2
3
4
5
6
7
8
| <?php
<?php
class a{
}
$b = new a();
var_dump($b);
|
创建类成员
- 类成员分类
- 成员变量(属性) 给对象存储的数据变量
- 成员函数(方法) 给对象调用解决问题的函数
- 类常量 属性类内部的常量，使用
const关键字定义
- 属性和方法需要用访问修饰符限制修饰符，使用
public修饰
咧：
函数用用修饰符应为他 默认就是public的
1
2
3
4
5
6
7
8
9
10
11
12
13
| <?php
class 类名{
public $属性名 =值;
const 变量名 =值;
function 方法名("行参"){
xxxxx
}
}
|
访问类成员
我们可以使用 new运算符来实例化该类的对象
简单就是说用new可以调用类
使用方法用的是->
咧
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| $b= new 类名();
echo $b->属性名;
$b->属性名="值";
$b->要添加的属性名="值";
unset($b->要删除的属性名)
$b->方法名("实参");
|
增删改查事例
查
咧：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| <?php
class Site {
public $url = "aaa";
const TITLE ="不好";
function setUrl($i){
echo "他好";
}
}
$a= new Site();
echo $a->url;
|
结果
改
咧：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| <?php
class Site {
public $url = "aaa";
const TITLE ="不好";
function setUrl($i){
echo "他好";
}
}
$a= new Site();
$a->url="bbb";
echo $a->url;
|
结果
增
咧：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| <?php
class Site {
public $url = "aaa";
const TITLE ="不好";
function setUrl($i){
echo "他好";
}
}
$a= new Site();
$a->twourl="ccc";
echo $a->twourl;
|
结果
删除
删除用到unset
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| <?php
class Site {
public $url = "aaa";
const TITLE ="不好";
function setUrl($i){
echo "他好";
}
}
$a= new Site();
unset ($a->url);
echo $a->url;
|
访问方法
咧：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| <?php
class Site {
public $url = "aaa";
const TITLE ="不好";
function setUrl(){
echo "他好";
}
}
$a= new Site();
$a->setUrl();
|
结果
访问修饰限制符
public (默认是他) 公共的类内外都访问
protected（受保护的）只允许在相关的类内部访问
private（私有的） 只允许在定义类内部访问
public(公共的)
函数默认就是public
咧：
1
2
3
4
5
6
7
8
9
10
11
12
13
| <?php
class Site {
public $url = "aaa";
function setUrl(){
echo "他好";
}
}
$a= new Site();
echo $a->url;
$a->setUrl();
|
结果
protected（受保护的）
咧：
受保护的是不能被访问的
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| <?php
class Site {
protected $url = "aaa";
protected function setUrl(){
echo "他好";
}
}
$a= new Site();
echo $a->url;
$a->setUrl();
|
他会报错
private（私有的）
咧：
受保护的是不能被访问的
1
2
3
4
5
6
7
8
9
10
11
12
13
| <?php
class Site {
private $url = "aaa";
private function setUrl(){
echo "他好";
}
}
$a= new Site();
echo $a->url;
$a->setUrl();
|
结果报错
)
内类部对象
进行测访问内部对象
通过内部的函数访问类里面的变量
咧：
什么都没有显示
应为在类里面setUrl仍然是个函数url在函数外部是读取不了的
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| <?php
class Site {
protected $twourl="bbb";
private $url = "aaa";
function setUrl(){
echo $url;
echo $twourl;
}
}
$a= new Site();
$a->setUrl();
|
结果
$this的介绍
$this方法内部的内置的一个对象仅限内部使用
他可以访问任何访问限制符的成员
类内部函数对函数以为类内的变量也是通过$this来访问的
通过$this可以访问全部的内容
咧：
先通过var_dump()来看一下$this的内容
下面结果可以看见通过$this可以访问全部的内容
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| <?php
class Site {
protected $twourl="bbb";
private $url = "aaa";
function setUrl(){
var_dump($this);
}
}
$a= new Site();
$a->setUrl();
|
结果
使用”$this”来访问私有和受保护的
咧：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| <?php
class Site {
protected $twourl="bbb";
private $url = "aaa";
function setUrl(){
echo $this->twourl,$this->url;
}
}
$a= new Site();
$a->setUrl();
|
结果
可以访问
范围解析操作符”::”
什么是范围解析操作符，可以用于访问静态成员，类常量，还可以用于覆盖类中的属性和方法
他可以实现类直接访问类成员，是专门实现类成员操作的，可以实现类直接访问类成员的
语法
下面用一个普通的一个方法访问常量
1
2
3
4
5
6
7
8
9
| <?php
class Site {
const PI ="aaaaa";
}
$a= new Site();
$a->PI;
|
结果就报错了
我们就可以用范围解析操作符”::”了
咧：
1
2
3
4
5
6
7
| <?php
class Site {
const PI ="aaaaa";
}
echo Site::PI;
|
结果
他其实也可以直接访问操作类内的方法和属性但是不建议怎么做
静态成员
什么用静态成员：就是用static关键字来修饰的类成员，表示该成员属于类访问的
php有两个静态成员
访问静态成员要用到范围解析操作符”::”
简单实例访问静态属性
下面这个访问静态属性要叫上$符号
1
2
3
4
5
6
7
8
9
10
11
12
| <?php
class Site {
public $url="aaaaa";
public static $PI="ccccc";
}
echo Site::$PI;
|
结果
访问方法静态方法
实咧：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| <?php
class Site {
public $url="aaaaa";
public static function PI(){
echo "cccc";
}
}
echo Site::PI();
|
结果
在类的内部访问类内的静态属性
不建议这样使用
咧：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| <?php
class Site {
public $url="aaaaa";
public static $Siteurl="ccccc";
public static function PI(){
echo Site::$Siteurl;
}
}
echo Site::PI();
|
结果
