menu linbiwei
account_circle

正在努力加载中QAQ

php 面向对象基础
date_range 2019-03-06 14:32
apps php
local_offer 查看标签
comment 0 条评论
浏览:155

对象

对象: 拥有相同属性和方法的集合
class 类名(首字母大写或者驼峰式){
public 属性名=属性值;//类属性
//类的方法
public function 方法名(){

}
}
对象操作:
$xx(保存实例化结果)=new 类名
$xx->属性 访问对象的属性
$xx->方法() 访问对象的方法
$this->属性 本类的属性
$this->方法() 本类的方法
eg:
<?php
 //计算类
 class CountNum{
   public $a=5;
   public $b=6;
   /*
   类里面的变量仍然是局部变量
   */
   public function add(){
     $this->test();
     //var_dump($this->a);exit;
     return $this->a+$this->b;
   }
   public function mid(){
     return $this->a-$this->b;
   }
   public function plus(){
     return $this->a*$this->b;
   }
   public function chu(){
     return $this->a/$this->b;
   }
   public function test(){
     echo 1;
   }
 }
$c=new CountNum;//实例化计算类
$c->a=7;
$c->b=6;
var_dump($c->add());
var_dump($c->mid());
var_dump($c->chu());
var_dump($c->plus());

面向对象四大特性

继承 extends
子类可以全部继承父类的公开方法和属性
重载 子类必须大于等于父类权限
子类可以改写父类的方法和属性
多态 (不支持多态)
封装
public 公开,公共 所有子类和本类的内部都可以使用的,外部
protected 受保护的 本类和子类使用,外部不能调用
private 私有化 本类访问

魔术函数

__construct() 构造函数 类实例化的时候自动调用
__destruct() 析构函数 类销毁
eg:
<?php
class Person{
  /*人类的属性*/
  public $eye='黑色';
  public $mouth='';
  public $foot='';
  
  public function __construct($f='缓慢爬行',$m='嗷嗷嗷'){
     echo '新人类诞生啦<br/>';
    $this->mouth=$m;
    $this->foot=$f;
     $this->move();
    $this->say();
  }
  /*
  人类的行为
  */
  public function move(){
    echo $this->foot.'<br/>';
  }
  /*
  人类的语言
  */
  public function say(){
    echo $this->mouth.'<br/>';
  }
  
  public function __destruct(){
    echo '新人类死亡啦<br/>';
  }
}
class GoodPerson extends Person{
  public $eye='蓝色';
  public function move(){
    echo '我是神奇大侠<br/>';
  }
  public function move($word){//不支持多态
    echo '我是神奇大侠1<br/>';
  }
}
/*
$p=new Person;
//$p->move();
//$p->say();
unset($p);
$p1=new Person('快速爬行','呃呃呃');
unset($p1);
$p2=new Person('飞速爬行','哟哟哟');
unset($p2);
*/
$gp=new GoodPerson;
echo $gp->eye.'<br/>';

$this、parent、self

$this 本类
parent 父类
self 自己

动态变量、动态属性和静态变量、静态属性

动态变量,动态属性:
方法调用、类实例化就会还原
静态变量,静态属性
不会跟随方法调用,类实例化还原
oop里面静态属性不能重载为非静态的属性,可以不实例化的前提直接访问
oop的静态方法是可以不实例化的前提直接访问的
eg:
<?php
class Person{
    /*人类的属性*/
    public static $eye='黑色';
    public $mouth='';
    public $foot='';
    public function __construct($f='缓慢爬行',$m='嗷嗷嗷'){
    echo '新人类诞生啦<br/>';
    $this->mouth=$m;
    $this->foot=$f;
    $this->move();
    $this->say();
    }
    /*
    人类的行为
    */
    public function move(){
    echo $this->foot.'<br/>';
    }
    /*
    人类的语言
    */
    public function say(){
    echo $this->mouth.'<br/>';
    }
    public function __destruct(){
    echo '新人类死亡啦<br/>';
    }
}
class GoodPerson extends Person{
    public static $eye='蓝色';
    public function move(){
    echo '我是神奇大侠<br/>';
    echo Person::$eye;
    }
    
    public static function test(){
    echo '我是静态方法<br/>';
    }
}
/*
function test(){
static $a=1;
$a++;
return $a;
}

echo test();
echo test();
echo test();
echo test();
*/
//$p=new Person;
//$gp=new GoodPerson;
//echo GoodPerson::$eye;
echo GoodPerson::test();

魔术方法

__get 访问不存在的受保护及限制属性时候自动触发
public function __get($name){
var_dump($name);
}
__set 给不存在或受保护及限制的属性赋值的时候自动触发
public function __set($name,$value){
self::$$name=$value;
}
__isset 
阻止判断不存在或受限制及保护的属性
__call 访问不存在或受保护的方法 
public function __call($method,$parm){
call_user_func_array(array($this,$method),$parm);
}
eg:
<?php
class F{
  const NAME='父亲路人甲';//常量
  public static $money=1000;
  private static $selfMoney=100000000;
  
  public function __get($name){
    //echo '亲,这个属性没有哦<br/>';
    echo self::$$name.'<br/>';
  }
  
  public function __isset($name){
   return true;
  }
  
  public function __unset($name){
    return true;
  }
  
  public function __set($name,$value){
    self::$$name=$value;
  }
  
  public function __call($method,$parm){
    call_user_func_array(array($this,$method),$parm);
  }
  /*
  父类买东西
  */
  public function buy($m){
    //$this->money=$this->money-$m;
   self::$money=self::$money-$m;
  }
  
  private function test(){
    echo self::$selfMoney.'<br/>';
  } 
  
  public function countTotal(){
    echo '钱包还剩下:'.self::$money.'<br/>';
  }
}

class S1 extends F{
  const NAME='儿子路人乙';//重载常量
}
$f=new F;
echo '本来钱包有:'.$f::$money.'<br/>';
//echo $f::$selfMoney.'<br/>';
$f->buy(200);
echo $f::NAME.'<br/>';
$f->countTotal();
$s1=new S1;
//echo $s1->test().'<br/>';
echo '本来钱包有:'.$s1::$money.'<br/>';
//$s1->selfMoney=0; //__set()
echo $s1->selfMoney; //__get()
$s1->test();         //__call()
echo $s1::NAME.'<br/>';
$s1->buy(300);
$s1->countTotal();
var_dump(isset($f->selfMoney)); //__isset()
当类实例化不成功因为类不存在的时候,自动触发去查找相关类
function __autoload($name){
include(strtolower($name).'.php');

}
eg:
<?php
function __autoload($name){
   include(strtolower($name).'.php');
   //var_dump($name);
}
$a=new A;
a.php
<?php
 class A{
   public function __construct(){
     echo 'A类加载成功';
   }
 }
b.php
<?php
 class B{
    public function __construct(){
     echo 'B类加载成功';
   }
 }

克隆

<?php
class User{
   public $username = 'sky';
   public $password = 123123;
   //当对象被克隆时调用,防止克隆时候把重要的信息克隆到
   public function __clone(){
      $this->password ="";//密码不能外泄,克隆时把密码清空
   }  
}
$u1 = new User();
var_dump($u1);
$u2 = clone $u1;
var_dump($u2);

常量

<?php
/*
const:在类中定义一个常量
调用:类名::常量名
意义:为了保证类的独立性,防止常量冲突
*/
define('NAME','tom');//公共常量
class Test{
   const NAME = 'miny';//只属于本类,可以被重载,不能在外部赋值,只在本类有效
   public function showName(){
      echo NAME.'<br>';
      echo Test::NAME.'<br>';
   }
}
$test = new Test;
$test->showName();
echo NAME.'<br>';
echo Test::NAME.'<br>';

抽象类 方法

<?php
/*
抽象方法:
1 不能实例化
2.抽象方法可以规范子类的格式
3.抽象方法不能是私有的,因为私有方法不能被重载
*/
abstract class F{
  const NAME='父亲路人甲';
  public static $money=1000;
  private static $selfMoney=100000000;
  public function __get($name){
    echo self::$$name.'<br/>';
  }
  /*
  抽象方法是没有方法体(没有内容)
  内容由子类去决定,而且子类是必须一定要实现抽象方法
  */
  abstract function buy();
}
class S1 extends F{
  public function buy(){
    echo self::$money=self::$money-100;
  }
}
$s1=new S1;
$s1->selfMoney;
$s1->buy();

接口(多继承)

<?php
/*
interface:接口
implements:实现接口
用处:完全用于规范子类的方法,强制子类必须实现某方法
特点:
1、接口中只能定义常量或不完全方法
2、接口中的方法在子类中都必须实现(重载)
3、接口是一个特殊的类,它不被继承,而被实现,而且可以是多实现
interface > abstract > 普通类
*/
interface Test{
   //public $t1;
   //static public $t2;
   const T3='sky';
   /*public function t4(){
   }
   */
   public function t5();
}
interface Test2{
   public function t6();
}
class C implements Test,Test2{
   public function t5(){
   }
   public function t6(){
   }
   public function t7(){
   }
}
//例子:鸟人
interface Animal{
   public function eat();//鸟和人都具有吃的方法,为避免接口方法冲突(php5.4后无此问题),应将该方法提出到上一级的接口中
}
interface Person extends Animal{
   public function think();
   public function talk();
}
interface Bird extends Animal{
   public function fly();
}
class BridPerson implements Person,Bird{
   public function think(){
   }
   public function talk(){
   }
   public function fly(){
   }
   public function eat(){
   }
}
版权声明:本站文章采用知识共享署名4.0 国际许可协议进行许可,请在转载时注明出处及本声明!
名称不能为空
email
邮箱不能为空,请填写正确格式
link
网址请用http://或https://开头
message
评论不能为空
支持Markdown和LaTex数学公式
sentiment_very_satisfied

captcha
请输入验证码

keyboard_arrow_up