1、类
Class lio{
Public
Protect
Private
Function __constructor(){}
}
2、类的实例化
<?
php
class lio{
//定义属性，须要加权限修饰符
public $a="lveo";
//定义方法。须要加权限修饰符
public function running(){
echo 521;
}
public function lovea(){
echo "do something";
}
}
//类的实例化
$name=new lio();
//实例化对象的属性和方法訪问
echo $name->a;
$name->lovea();
?>
3、类的构造函数和析构函数
<?
php
class lio{
//定义属性，须要加权限修饰符
public $a="lveo";
//定义方法，须要加权限修饰符
public function running(){
echo 521;
}
public function lovea(){
echo "do something";
}
//不须要权限修饰符 public
function __construct($name){
echo "start";
//$this指实例化的对象
$this->name=$name;
}
function __destruct(){
echo "say goodBye";
}
}
//类的实例化
$name=new lio("sanmei ");
echo $name->name;
?>
4、析构函数
对象的赋值和引用,在对象$XXX=null;之后会产生不同结果
5、对象的继承（单继承）
<?php
class lio{
public $name='lio';
public $age=22;
//共同拥有方法
public function love(){
echo "love sanmei";
}
//不须要权限修饰符 public
function __construct($name){
echo "start ";
//$this指实例化的对象
$this->name=$name;
}
}
//类son继承 lio
class son extends lio{
function __construct($name){
echo "$name".'1234';
}
}
//类的实例化
$name=new son("sanmei");
//继承中，使用父类的方法
$name->love();
?
>
6、訪问控制
Public :共同拥有的类成员
Private : 私有的类成员
Protect : 受保护的，子类能够訪问
<?
php
class lio{
public $name='lio';
public $age=22;
//共同拥有方法
public function love(){
echo "love sanmei";
}
//protect
protected $pro="baohu";
//private
private $pri="siyoude";
//不须要权限修饰符 public
/* function __construct($name){
echo "start ";
//$this指实例化的对象
$this->name=$name;
} */
}
//类son继承 lio
class son extends lio{
public $pub="pub";
public function getpri(){
echo $pri;
}
//protect
protected $pro="baohu";
//private
private $pri="siyoude";
/* function __construct($name){
echo "$name".'1234';
} */
}
//类的实例化
$name=new son("sanmei");
//public能够訪问
echo $name->pub;
//protect仅仅在子类中
//通过public function 实现调用private属性
$name->getpri();
//private 仅仅在本类中
echo $name->pri;//会报错
?>
<?php
class fa{
public $a=123;
protected $b=234;
private $c=345;
public function xie(){
echo $this->c;//必须通过$this 来訪问
}
}
class son extends fa{
function __construct(){
$this->xie();
}
}
$na=new fa();
$na->xie();
?>
7、Static 静态keyword
<?php
class fa{
public $a=123;
protected $b=234;
private $c=345;
public static $d="love you";
public function xie(){
echo $this->c;//必须通过$this 来訪问
}
public function ss(){
//在类中静态属性通过self来定义
echo self::$d;
}
public static function dd(){
echo 1234;
}
}
class son extends fa{
function __construct(){
$this->xie();
}
//在子类中用parent来訪问 父类的静态变量
//echo parent::$d;
}
//在类外通过类名::直接訪问
echo fa::$d;
fa::dd();
//通过对象訪问
$na=new fa();
$na->xie();
$na->ss();
?>
静态方法不能用$this来訪问
8、Final keyword，防止又一次赋值 重写
Fatal error: Cannot override final method bs::text() in D:wampwwwStudyObjindex.php on line 18
<?php
//假设类前加上final则该类不能被不论什么类继承的类，能够在class之前加入final
class bs{
final public $a=123;
public function a(){
echo 123;
}
//不能在子类中重写方法
final public function text(){
echo "1231321";
}
}
class son extends bs{
//重写，和父类一致的方法
public function a($temp='lio'){
echo $temp;
}
public function text(){
echo 2345;
}
}
$lio=new son();
$lio->a();
?>
9、数据訪问
重写过程中用parent::来訪问父类中的方法。常量不须要$
10、对象接口
<?php
//接口仅仅有方法声明
interface ss{
public function eat($food);
}
//继承接口的类必须实现方法体
class son{
public $a=123;
public function eat($food){
echo "lio eat".$food;
}
}
//继承接口的类必须实现方法体
class sonn{
public $a=123;
public function eat($food){
echo "lio drink".$food;
}
}
$lio=new son();
$li=new sonn();
$lio->eat('nice');
$li->eat('water');
var_dump($li instanceof ss);
function check($obj){
if(var_dump($obj instanceof ss)){
$obj->eat('lio');
}else{
echo "cant eat";
}
}
能够用extends 实现接口继承接口
?>
11、多态
就是同一个接口，不同类去继承的时候，实现的方法体可能会不一样，这样就造成了多态。极大地提高了灵活性
传入对象不同。实现的方法不同
var_dump($li instanceof ss);
function check($obj){
if(var_dump($obj instanceof ss)){
$obj->eat('lio');
}else{
echo "cant eat";
}
}
12、抽象类
方法能够实现也能够不实现。间与接口和类之间
<?
php
//抽象类里的方法能够实现,抽象方法仅仅有声明。没有方法实现，非抽象方法能够有方法体
abstract class lio{
public $a=123;
public function name($name){
echo $name;
}
abstract public function aa(){
echo 132123;
}
}
class son extends lio{
function __construct(){
echo "start";
}
}
$name=new son();
$name->name('Lio');
?
>
13、魔术方法--- __tostring()和__invoke()
当成字符串输出时
<?php
class lio{
function __toString(){
//必须是return
return "12345";
}
}
$name=new lio();
echo $name;
?
>
当成方法时
<?php
class lio{
function __toString(){
//必须是return
return "12345";
}
function __invoke($temp){
echo $temp;
}
}
$name=new lio();
$name(5);
?>
14、魔术方法--- __call和__callStatic
<?php
class lio{
//重载
public function __call($name,$arguments){
echo "wo ai sanmei";
}
public static function __callstatic($name,$arguments){
echo "static wo ai sanmei";
}
}
$name=new lio();
$name->asd('lio','lio');
lio::res('lio','lio');
?
>
15、魔术方法--- __get()和__set()
<?php
class lio{
public function __get($name){
return "123123";
}
public function __set($name){
echo 123123123;
}
}
$name=new lio();
//就像定义了一样去使用
echo $name->time;
$name->time=1231312321313;
?
>
16、魔术方法--- __isset()和__unset()
属性的重载
17、魔术方法--- __clone()
<?php
class lio{
public $name=123;
function __clone(){
//在clone的时候不一样
$this->name="love you";
}
}
$name=new lio();
$name->name='aaaaa';
echo $name->name;
$san=clone $name;
echo $san->name;
$san->name='sssssss';
echo $san->name;
//使用lone初始化的name，在改变数据但不影响原对象
$mei=clone $name;
?>