1.创建一个类
class Base
{
public function index()
{
echo '这是Base类里面的index方法';
}
}
class User extends Base
{
//公开
public $name;
//受保护的
protected $arr;
//私有属性
private $_age;
//静态属性
public statis $account;
//定义常量
const content = '这是常量哦';
/*
有三种方法赋值私有的成员变量
*/
//构造函数,在类被实例化时调用【1.在构造方法里】
public function __construct($age,$arr)
{
$this->_age = $age;
$this->arr = $arr;
}
//【2.再编写一个公开方法】
public function access()
{
$str = [];
return $str = [$this->_age,$this->arr];
}
//【3.使用魔术方法】
/**
* 访问类中私有属性时自动调用,传递读取属性名,返回$this->属性名
* @param [type] $value [description]
* @return [type] [description]
*/
public function __get($value)
{
return $this->$value;
}
/**
* 给类的私有属性赋值时自动调用,传递需设置的属性名,属性值
* @param [type] $key [description]
* @param [type] $value [description]
*/
public function __set($key,$value)
{
return $this->$key = $value;
}
/**
* [__destruct description]
* 析构方法,在类被调用结束时自动调用
*/
public function __destruct()
{
return '销毁变量';
}
/**
* [index description]声明一个普通公开的方法
* @return [type] [description]
*/
public function index()
{
//想要继承base类里面的方法,两个类的index方法都想起作用,不想重载Base类的index
parent::index();
echo '这是一个公开的方法,所有人都可以访问';
//在类的内部访问静态属性
self::account;
echo '<hr />';
//访问静态方法
self::make();
//访问常量
echo '<hr />';
self::content;
}
/**
* [save description]受保护的方法
* @return [type] [description]
*/
protected function save()
{
echo '这是一个受保护的方法,只有在类的内部和子类的(被继承的类的内部可以访问)';
}
/**
* [edit description]私有的方法
* @return [type] [description]
*/
private function edit()
{
echo '这是一个受保护的方法,只有在类的内部自己访问';
}
/**
* [make description]静态方法
* @return [type] [description]
*/
public static function make()
{
echo '这是一个公开的静态方法';
}
/**
* [__call description]__call():调用一个类中未定义的或未公开的方法时自动调用,传递被调用的函数名及参数列表
* @return [type] [description]
*/
public function __call($functionName,$functionParams)
{
print_r("你调用的方法是".$functionName.'它的参数是'.$functionParams);
}
}
//类的属性方法的访问
$user = new User();
//访问属性
echo $user->name;
//给属性赋值
$user->name = 'li';
//访问方法
$user->index();
//访问静态属性
User::account;
//访问静态方法
User::make();
/*
抽象类
关键字 abstract
*/
abstract class Good
{
//在抽象类可以定义属性
protected $username = 'tianerjun';
public function __constract()
{
echo '这是一个构造方法';
}
/*
(抽象方法)必须是空白的方法
*/
abstract function index();
/*
在抽象类内可以有写好的方法
*/
public function save()
{
echo '这是抽象类的方法';
}
/*
抽象类的属性在类里面可以使用
*/
public function edit()
{
return $this->username;
}
}
//抽象类是不可以实例化的,可以被继承,通过extends继承,一个方法只能继承一个抽象类
class Svn extends Good
{
public function index()
{
echo '这是抽象类Good中index方法的实现';
}
public function store()
{
echo '这是Svn类store方法';
}
}
$svn = new Svn();
/*
接口
关键字 interface
*/
interface Root
{
/*
接口类的方法不用实现
*/
public function index(){}
public function save(){}
}
//接口不能被实例化,可以被继承(说继承可能不太合适)它是通过关键字实现的【implements】,一个类可以同时继承多个接口,继承多个接口需要实现父接口中所有未实现的方法
class Blog implements Root
{
public function index()
{
echo '这是接口index方法的实现';
}
public function save()
{
echo '这是接口save方法的实现';
}
}
$blog = new Blog();