类
类是对对象抽象的一个描述。
不能被执行，不能使用。
类的实例化结果就是对象
<?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
final关键字：主要使用修饰了类与成员方法（函数）。
使用final关键字修饰类，表示这个类不可以有子类。
使用final关键字修饰的方法，不可以在子类中被覆盖（重写）。
目的：安全、没必要。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";//修改静态属性
- 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";//指定绝对路径找到当前空间下的函数
