类的定义和实例化
<?php
// 类的定义使用class
class Demo{
// 定义属性
public $username="s0mf";
public $password="admin_s0mf";
// 定义方法
public function test(){
echo "This is test!";
}
}
// 类到对象实例化
$demo = new Demo();
// 对象中的成员属性可以用->来访问
echo $demo->username;
// 对象中的成员方法可以用->来访问
$demo->test();
代码运行：
s0mfThis is test!
构造函数
<?php
class Demo{
public $username="s0mf";
public $password="admin_s0mf";
// 默认的构造函数，在对象被实例化的时候自动调用
// 构造函数通常用于初始化对象的属性值
function __construct($username,$password){
echo "构造函数...";
// $this是php里面的伪变量，表示对象自身
// 通过$this可以设置对象的属性值
$this->username = $username;
$this->password = $password;
}
public function test(){
echo "This is test!";
}
}
$demo = new Demo("s0mf","admin_s0mf");
echo $demo->username."
";
echo $demo->password;
echo "<hr/>";
$demo2 = new Demo("admin","admin888");
echo $demo2->username."
";
echo $demo2->password;
代码运行：
构造函数...s0mf admin_s0mf
构造函数...admin admin888
析构函数
<?php
class Demo{
public $username="s0mf";
public $password="admin_s0mf";
function __construct($username,$password){
echo "构造函数...";
$this->username = $username;
$this->password = $password;
}
// 析构函数，用于清理程序中使用的系统资源，比如释放打开的文件等等
// 析构函数在该对象不会再被使用的情况下自动调用
function __destruct(){
echo "析构函数...";
print "Destroying " . $this->username . "
";
}
public function test(){
echo "This is test!";
}
}
$demo = new Demo("s0mf","admin_s0mf");
echo $demo->username."
";
echo $demo->password;
// 当对象变量被赋值为Null的时候，对象的析构函数会被自动调用
$demo = null;
echo "析构结束";
继承
<?php
/**
* 继承
* 1. 定义Human
* 2. 让Person继承Human
* 3. PHP中类不允许同时继承多个父类，也就是extends后面只能跟一个父类名称，这个特性被称为PHP的单继承特性
*/
class Human{
public $name;
public $sex;
public $age;
public function study($book){
echo $this->name."'s studying ".$book."
";
}
}
// extends关键字用于说明该类继承自某个父类
class Person extends Human{
public $e_mail;
function __construct($name, $sex, $age, $e_mail){
$this->name =$name;
$this->sex =$sex;
$this->age =$age;
$this->e_mail =$e_mail;
}
}
$person = new Person("s9mf", "男", "16", "s9mf@qq.com");
echo $person->e_mail."
";
$person->study("php");
/***
** 运行代码
** s9mf@qq.com s9mf's studying php
****/
访问控制
private protected public
本类内 Y Y Y
子类内 N Y Y
外部 N N Y
<?php
class Human{
private $name="陈先生";
protected $money = 4500;
public $age= 30;
public function say(){
echo '我叫',$this->name,'<br />';
echo '我每月用',$this->money,'<br />';
echo '我今年',$this->age,'岁<br />';
}
}
class Stu extends Human{
private $friend = '铁柱';
public function talk(){
echo '我叫',$this->name,'<br />';
echo '我每月用',$this->money,'<br />';
echo '我今年',$this->age,'岁<br />';
}
}
$ming = new Stu();
$ming->say(); // 都可以在本类内调用
$ming->talk(); // 不允许在子类调用private ，但是 protected，public允许
echo "<hr>";
echo $ming->age;
echo $ming->name; //出错 不允许在类外调用private
echo $ming->friend; //出错 不允许在子类调用private
echo $ming->money; // 出错 不允许在类外调用protected
代码运行：
我叫陈先生
我每月用4500
我今年30岁
我叫
Notice: Undefined property: Stu::$name in D:phpStudyPHPTutorialWWWphpdemo.php on line 17
我每月用4500
我今年30岁
30
Notice: Undefined property: Stu::$name in D:phpStudyPHPTutorialWWWphpdemo.php on line 27
Fatal error: Cannot access private property Stu::$friend in D:phpStudyPHPTutorialWWWphpdemo.php on line 28
Static(静态)关键字
<?php
class Human{
public $name;
public $sex;
public $age;
public static $test="这是父类成员属性";
public function study($book){
echo $this->name."'s studying ".$book."
";
}
}
class Person extends Human{
public $e_mail;
public static $teacher = "叶华";
public static function changeTeacher($newteacher){
// self或static用于表示当前类，"::"操作符用于访问类的静态成员
self::$teacher = $newteacher;
// parent用于表示父类，可以用于访问父类的静态成员
echo parent::$test . "
";
}
function __construct($name, $sex, $age, $e_mail){
$this->name =$name;
$this->sex =$sex;
$this->age =$age;
$this->e_mail =$e_mail;
}
}
// 类名加“::”可以访问类的静态成员
// 静态成员不需要实例化就可以访问
echo Person::$teacher;
Person::changeTeacher("谷哥");
echo Person::$teacher;
代码运行：
叶华这是父类成员属性 谷哥
重写与Final
<?php
/**
* 重写和Final
* 1. 子类中编写跟父类完全一致的方法可以完成对父类方法的重写
* 2. 对于不想被任何类继承的类可以在class之前添加final关键字
* 3. 对于不想被子类重写（overwrite, 修改）的方法，可以在方法定义前面添加final关键字
* 4.如果一个类被声明为 final，则不能被继承。final class B
* 5.属性不能被定义为 final，只有类和方法才能被定义为 final。
* 6.如果父类中的方法被声明为 final，则子类无法覆盖该方法
* 7.不在子类重写时，可以调用
*/
class B{
// final关键字 test()不能被重写
final public function test(){
echo "B::test called
";
}
public function test1(){
echo "B::test1 called
";
}
}
class A extends B{
// 父类test()方法的重写
// 重写时参数不一定要跟父类完全一致
public function test($tmp=0){
echo "A::test called
".$tmp;
}
}
$obj = new A();
$obj->test("tmp");
$obj->test1();
数据访问
<?php
/**
* 数据访问补充
* 1. parent关键字可以用于调用父类被重写的类成员
* 2. self关键字可以用于访问类自身的成员方法，也可以用于访问自身的静态成员和类常量；不能用于访问类自身的属性；访问类常量时不用在常量名称前面加$符号
* 3. static关键字用于访问类自身定义的静态成员，访问静态属性时需要在属性名前面添加$符号
*/
class B{
public function test(){
echo "B::test called
";
}
public function test1(){
echo "B::test1 called
";
}
}
class A extends B{
// 常量属性
const CONST_VALUE = 'A constant value';
private static $sValue = 'static value';
public function test($tmp=null){
echo "A::test called
".$tmp;
// parent可以访问父类中被子类重写的方法
parent::test();
self::called();
echo self::CONST_VALUE."
";
echo static::$sValue."
";
}
public function called(){
echo "A::called called
";
}
}
$obj = new A();
$obj->test();
接口
<?php
// interface用于定义接口
interface Read_book{
// 接口里面的方法不需要有方法的实现
public function read($book);
}
// implements用于表示类实现某个接口
class Human implements Read_book{
// 实现了某个接口之后，必须提供口中定义的方法的具体实现
public function read($book){
echo "Human reading ".$book."
";
}
}
class XiaoMing implements Read_book{
public function read($book){
echo "XiaoMing reading ".$book."
";
}
}
$obj = new Human();
$obj->read("<降龙十八掌>");
$xm = new XiaoMing();
$xm->read("<隔山打牛>");
// 不能实例化接口
// $read = new Read_book();
//
var_dump($obj instanceof Read_book);
function checkEat($obj){
if($obj instanceof Read_book){
$obj->read("葵花宝典");
}else{
echo "It's can't";
}
}
//同样的代码，传入接口的不同实现类的时候，表现不同。这就是为什么成为多态的原因。
checkEat($obj);
checkEat($xm);
// 可以用extends让接口继承接口
interface ICanPee extends Read_book{
public function pee();
}
// 当类实现接口时，父接口定义的方法也需要在这个类具体实现s
class Human1 implements ICanPee{
public function pee(){}
public function read($book){}
}
抽象类
<?php
/**
* 抽象类
* 1. 抽象类允许类里面的部分方法暂时没有具体实现，这些方法我们成为抽象方法
* 2. 一旦类里面有抽象方法，这个类就必须是抽象类
* 3. 抽象类跟接口一样，不能直接实例化为对象
*/
// abstract定义抽象类
abstract class ACanEat{
// 没有实现的方法需要设定为抽象方法
// 抽象方法需要在子类中实现
//这里定义的抽象方法。
abstract public function eat($food);
public function breath(){
echo "Breath use the air.
";
}
}
// Human类实现了ACanEat接口
class Human extends ACanEat{
public function eat($food){
echo "Human eating ".$food."
";
}
}
// Animal类实现了ACanEat接口
class Animal extends ACanEat{
public function eat($food){
echo "Animal eating ".$food."
";
}
}
$man = new Human();
$man->eat("Apple");
$man->breath(); // 和Animal共用了抽象类ACanEat的breath方法
$monkey = new Animal();
$monkey->eat("Banana");
$monkey->breath();
魔术方法
<?php
class MagicTest{
public function __tostring(){
return "This is the Class MagicTest ";
}
public function __invoke($x){
echo "__invoke called " . $x . "
";
}
}
$obj = new MagicTest();
echo $obj;
$obj("6");
__call 与 __callStatic
<?php
class MagicTest{
// 方法的重载
public function __call($name, $arguments){
echo "Calling ".$name."with parameters: ".implode(",", $arguments)."
";
}
// 静态方法的重载，注意这个方法需要设置成static
public static function __callStatic($name, $arguments){
echo "Static calling ".$name."with parameters: ".implode(",", $arguments)."
";
}
}
$obj = new MagicTest();
$obj->runTest("para1","para2");
echo "<hr>";
MagicTest::runTest("para1","para2");
<?php
class Human{
private function t(){
}
public function __call($name, $arg){
echo '你想调用不存在的方法 ',$name,'方法<br/>';
echo '还想传一个参数<br/>';
echo print_r($arg),'<br/>';
}
public static function __callStatic($name, $arg){
echo '你想调用不存在的方法 ',$name,'静态方法<br/>';
echo '还想传一个参数<br/>';
echo print_r($arg),'<br/>';
}
}
$obj = new Human();
$obj->t(1,2,3);
Human::s0mf("s0","mf");
