php面向对象相关技术

• step1 一个经典类的设计和实例化

<?php
class mycoach
{
    　　public $_name='';
    　　public $_age='';
    　　public $_expert=array();
    　　public function __construct($name,$age,array $expert)
       {
        　　　　$this->_name=$name;
        　　　　$this->_age=$age;
        　　　　$this->_expert=implode("、",$expert);
    　　}
    　　public function self_introduce()
    　　{
　　　　echo sprintf("大家好！我是%s，职业拳手，今年%s，我会%s，快来找我训练吧%s",$this->_name,$this->_age,$this->_expert,"<br/>");
    　　}
}
$cpc = new mycoach('陈培昌',21,array("散打","泰拳"));
$cpc->self_introduce();
$cj = new mycoach('程劲',19,array('散打','泰拳','巴西柔术'));
$cj->self_introduce();
?>
关键点一：函数传参的时候如果是个数组要声明数据类型为array ：public function __construct($name,$age,array $expert)
关键点二：要获取数组里的值，要使用implode方法把数组炸开implode("、",$expert)，第一个参数是指明用什么符号分割这些值
结果:

类公有变量访问方式 $this->变量名 = xxxx;

类常量的访问方式 类名::常量名，注意常量名之前不能带$,那是变量的作法

<?php
class cpcsalary
{
    const basepoint = 2000;
    public function workall($salesbonus,$coursebonus)
    {
        echo sprintf("小松鼠这个月的工资是：%f",(cpcsalary::basepoint+$salesbonus+$coursebonus));
    }
}

$cpc = new cpcsalary();
echo "小松鼠的基本工资是:".(cpcsalary::basepoint)."<br/>";
$cpc->workall(68.8,2500);
?>
结果

• _destruct析构方法，类实例化之后

<?php
class imcj{
    public $_name;
    public $_age;
    const nickname="小烤肠";
    public function __construct($name,$age){
        $this->_name=$name;
        $this->_age=$age;
    }

    public function self_construct()
    {
        echo sprintf("我是%s,昵称是%s,今年%s",$this->_name,imcj::nickname,$this->_age)."<br/>";
    }

    public function __destruct(){
        echo "训练这么辛苦，还要干活，馆主又不给钱，拜拜了您呐"."<br/>";
    }
}
$cj = new imcj('程劲',19);
$cj->self_construct();
?>
结果：

• 私有属性，私有方法的类外访问

<?php
class tornado
{
    private $name="gaoyixuan";
    protected $name2="gaoyixuan我艹你妈";
    public function getname()
    {
        return $this->name;
    }

    private function comments($words)
    {
        echo $words;
    }

    public function addcomments($words)
    {
        $this->comments($words);
    }
}

$wenwa = new tornado();
echo sprintf("带人犯%s",$wenwa->getname())."<br/>";
$wenwa->addcomments("视频里人摸狗样儿的，其实他妈的不是个东西！！")
?>
结果是：

• 演示一下子类能否调用父类的private和protected类型变量

class subtornado extends tornado
{
    public function showname()
    {
        echo "你说能打印出来么".$this->name2."<br/>";
    }

    public function tellthesecret() {
       echo "我觉得够呛能打印出来".$this->name."<br/>";
    }
}

$wenheichouwa = new subtornado();
$wenheichouwa->showname();
echo "============================";
$wenheichouwa->tellthesecret();
?>
打印结果：显然作为private类型的变量$name无法被子类调用，而protected类型的$name2则可以

• 抽象类  无法被实例化，可以被继承，是一种规定好了的类的模子
• 单一继承和多继承：注意44行那个红叉子，由于php只支持单一继承，所以多继承必须用到接口技术

某个类实现（implements）了某个接口和继承（extends）了某个类的区别？

实现接口和继承很类似，但接口不能直接创建自己的对象

继承的父类必须有该方法的具体实现，子类可以重写父类的方法，也可以不写

接口里面的方法是不需要具体实现的，只要定义了方法的名称和参数即可，具体的实现必须在实现类中定义

一句话概括： 类的方法必须有实现，接口的方法必须为空。

<?php

interface ritz{
function trainning();
function teaching();
}

interface mybf extends ritz {
function judging();
}

class mycoach implements mybf{

public $_name="";

public function __construct($name){
$this->_name = $name;
}

public function trainning()
{
printf ("%s正在训练",$this->_name);
}

public function teaching()
{
printf ("%s正在教课",$this->_name);
}

public function judging(){

printf ("%s正在裁判比赛",$this->_name);
}
}

$cpc = new mycoach('帅厉猴儿');
$cpc->trainning();
echo "<br/>";
$cpc->teaching();
echo "<br/>";
$cpc->judging();
echo "<br/>";

?>

执行结果：

• abstract 抽象类：无法被实例化，至少要包含一个抽象方法(其实没有也行嘿嘿嘿)，没有方法体

//常规形式
abstract Class AbstractClass
{
    abstract public function A();//这里不要携带body
    abstract protected function B();//这里不要携带body
    public function C(){}//这里要携带body
}

<?php
abstract class mycoach
{
    public function sayhi(){}
    //abstract function wenwa();
}
class tianheiwa extends mycoach
{
    public $_name ="";
    public function __construct($name){
        $this->_name=$name;
    }
    public function sayhi(){
        printf( "大家好,我是%s",$this->_name);
    }
}
$cj = new tianheiwa("程劲");
$cj->sayhi();
?>
结果是：

• final类

final关键字，如果父类中的方法被声明为final，则子类无法覆盖该方法，如果一个类被声明为final，则不能被继承。

• 静态类

静态方法：
从程序运行开始 就实例生成内存 ，所以可以直接调用，效率会高很多，但是静态内存是有限制的，实例太多，程序直接启动不了，静态内存会常驻
非静态方法：
实例方法开始生成内存，在调用时申请零散的内存，所以效率会慢很多 ，非静态的用完就释放了
总体来讲都各有优势，什么时候用，都视情况而定

<?php
class coachsalary
{
private static $home = "三里屯酒吧一条街";
public static $_names = array();
public function __construct(array $allname){
self::$_names = implode(",",$allname);
}
public static function whichhome()
{
printf("小伙子们原来住在%s",self::$home);
echo "<br/>";
self::$home = "仿颐园搏击公寓";
printf("%s现在住在%s",static::$_names,self::$home);
echo "<br/>";
}
}
$sniffsocks = new coachsalary(array('厉智','陈培昌','程劲'));
coachsalary::whichhome();
?>