php-类

类

类是对对象抽象的一个描述。
不能被执行，不能使用。
类的实例化结果就是对象

<?php
//类的定义
  class Demo
  {
    //成员属性（成员变量）
    public $name ="zhangsan";

    //成员方法（函数）
    public function add()
    {
      echo "执行添加...\n";
    }
    public function show()
    {
      echo "执行浏览...\n";
    }
  }
  //类的实例化结果就是对象
  $d =new Demo();

  //使用（方法调用）
  $d->add();
  $d->show();

面向对象编程的特点：封装、继承、多态
类和对象的关系：

• 类的实例化结果就是一个对象（类的）
• 对对象的

类的定义

[修饰符] class 类名
{
【成员属性】 定义变量
【成员方法】 定义函数
}

常用属性修饰符：public、proteced、private、static、var

<?php
//定义一个stu学生类
class Stu
{
  //定义属性
  public $name ="zhangsan";
  public $age = 20;
  //定义成员
  public function say()
  {
    echo "hello world!";
  }
  public function test()
  {
    $this->say();
    echo $this->name.":".$this->age."\n";
  }
}
  //对象实例化
  $stu=new $Stu();
  echo $stu->name."\n";
  echo $stu->age."\n";

<?php  
//构造方法和析构方法
calss stu
{
  public $name;
  public $age;

  //构造方法（固定），必填两个参数,$name,$age可设默认值
  public function __construct($name,$age)
  {
    $this->name=$name;
    $this->age=$age;
  }

  public function getInfo()
  {
    return $this->name.":".$this->age."\n";
  }
  //析构
  public function __destruct()
  {
    echo $this->name."对象被销毁\n"；
  }
}
$s1=new Stu("李四",22);
$s2=nwe Stu("王五",23);

echo $s1->getInfo();
echo $s2->getInfo();

对象的封装

<?php
//类的封装
class Stu
{
  private $name="zhangsan";
  private $age=20;

  public function __set($param,$value)
  {
    this->$param=$value;
  }
  public function __get($param)
  {
    if($param=="age")
    {
      reture "保密"；
    }
      return $this->param;
  }
}
//测试
$s=new Stu();

$s->name="lisi";

echo $s->name;
echo $s->age;

继承

假如B类继承A类，那么久继承了A中所有非私有属性和方法（函数）。
其中A叫父类（基类），B叫子类（派生类）。
class B extends A
{

}

<?php  
//类的继承
calss $A
{
    public $name="aa";
    public function fun()
    {
      echo "aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n";
    }
}

class B extends A
{
  //重写父类方法是为了升级，提升程序的可维护性
  public function fun()
  {
    echo "bbbbbbbbbbbbbbbbbbbbbb\n";
  }

  //提升可扩展性
  public function fun2()
  {
     echo "cccccccccccccccc\n";
  }
}

final、static和const

1. final关键字：主要使用修饰了类与成员方法（函数）。
   使用final关键字修饰类，表示这个类不可以有子类。
   使用final关键字修饰的方法，不可以在子类中被覆盖（重写）。
   目的：安全、没必要。

2. static
   使用static修饰的方法和属性，不用实例化就可以使用。
   static修饰的方法中，不可以使用非静态内容（$this）。
   在类中调用属性，使用self::属性名
   在类外调用属性，使用类名::属性名

<?php
  class $A
  {
    public static name="zhangsan";
    public static function aaa()
    {
      echo "aaaaaaaaaaaaaaaaa\n";
    }
  }
  //静态方法，不用实例化，使用类名加双冒号调用
  echo A::aaa();
  echo A::name;
  A::name="lsi";//修改静态属性

3. const
   在类中修饰成员属性，将其定义成常量属性（不可修改）
   一般要求常量名都是大写的，没有"$"符，没有其他修饰符（public）
   定义格式：const 成员常用量="值"；
   在类中调用属性，使用self::属性名
   在类外调用属性，使用类名::属性名

<?php  
class Game
{
  const UP =37;
  const RIGHT=38;
  const DOWN=39;
  const LEFT=40;
  public function move ($c)
  {
    switch($c)
    {
      case 37:echo "向上移动。。。\n";
      case 38:echo "向右移动。。。\n";
      case 39:echo "向下移动。。。\n";
      case 40:echo "向左移动。。。\n";
    }
  }  
}



$g=new Game();
$g->move(37);
$g->move(Game::up);

4.检测当前对象是否是属性指定的类
instanceof 用于确定一个PHP变量是否属于某一类class的实例：
如果对象数据该类或该类是此对象的父类则返回 TRUE

类型约束

<?php
class A
{
  public function fun()
  {
    echo "aaaaaaaaaaaaaa\n";
  }
}
class B extends A
{
  public function fun()
  {
    echo "bbbbbbbbbbbbbbbbbbbbbbb\n";
  }
}
class Demo
{
  public function test(A $a)
  {
    $a->fun();
  }
}

$demo=new Demo();
$demo->test(new A());
$demo->test(new B);

魔术方法

• clone

__clone();//魔术方法  

当执行clone科隆时

• __toString
  必须返回一个字符串

<?php
class A
{
  public $name= "zhangsan ";
  public function __toString()
  {
    return "name".$this->name."\n";
  }
}

• __atuoload()
  当new实例化一个对象时，这个类若不存在，则自动调用此函数，并将类名存入参数可以使用这个实现类的自动加载。

<?php  
function __autoload($className)
{
  $fname=$calssName.".php";
  if(file_exists($fname))
  {
    require($fname);
  }
}

$s= new Stu("wangwu",20);
echo $s."\n";

对象序列化（串行化）（在对象持久化存储和传输中使用）

抽象类

<?php
//抽象类
abstract class A
{
    public function fun1()
    {
        echo "fun1()....\n";
    }
    public function fun2()
    {
        echo "fun2().....\n";
    }
    //抽象方法，没有方法体
    public abstract function fun3();
}
class B extends A
{
    public function fun3()
    {
        echo "fun3()...\n";
    }
}
//接口
interface C
{
    public function fun4();
    public function fun5();
    public function fun6();
}
//没有完全实现C类，不能实现
abstract class D extends implements C
{
    public function fun4()
    {
        echo "fun4()....\n";
    }
    public function fun5()
    {
        echo "fun5().....\n";
    }
}
class E extends D
{
    public function fun6()
    {
        echo "fun6()........\n";
    }
}



$b= new B();
$b->fun1();
$b->fun2();
$b->fun3();



$c=new C();
$c->fun4();
$c->fun5();
$C->fun6();

多态

对于同一个方法，传入不同对象，实现了不同的效果。
需要使用的技术：继承或实现，方法的覆盖。

命名空间

<?php
namespace aa;
function strlen($s)
{
    return 1000;
}
echo strlen("11")."\n";//调用当前空间下的函数
echo \strlen("adc")."\n";//调用根空间下的函数strlen()（系统函数）
echo \aa\strlen("123")."\n";//指定绝对路径找到当前空间下的函数