目录
一、类的定义
<?php
#类的属性：就是在类中定义的变量
#类的方法：就是在类中定义的函数
class Peoole{ //类的定义用class关键字进行描述
public $name='PHP'; //类的属性值只能是值，不能是变量、函数、对象等
public $age=20;
public $height=170;
public function eat($food){ //类的方法和函数类似
echo 'eat'.$food;
}
public function sleep(){
echo 'sleep....';
}
}
$peoole1=new Peoole(); //实例化类 用new关键字实例化出一个对象
echo $peoole1->name; //访问对象中的属性或方法 用->符号进行
$peoole1->eat('Apple');
$peoole1->sleep();
$peoole1->name='java'; //也可以修改对象的属性值
?>二、$this的作用
<?php
#在类中，通过$this访问自身属性和方法
class class1{
public $name='php';
public $age=20;
function fun1(){
echo 'fun1...';
}
function fun2(){
echo $this->name; //php
echo $this->age; //20
$this->fun1(); //fun1
}
}
$a=new class1();
$a->fun2();
?>三、构造函数与析构函数
<?php
header('content-type:text/html;charset=utf-8');
class class1{
public $name;
public $age;
function __construct($name,$age){ # #构造函数：实例化对象时，首先会调用构造函数，适合初始化
$this->name=$name;
$this->age=$age;
echo '构造函数被执行了<br />';
}
function __destruct(){ ##析构函数：当对象所有引用被删除或销毁前之前被调用 （可以通过析构函数释放结果集、资源、关闭连接等）
echo '析构函数被执行了<br />';
}
function test(){
echo $this->name.'<br />';
echo $this->age.'<br />';
}
}
$p1=new class1('PHP',20);
$p1->test();
/*
构造函数被执行了
PHP
20
析构函数被执行了
*/
?>四、封装之访问修饰符
<?php
/*
#封装性：外部只能调用或访问部分开放的属性和方法，不知道内部具体实现细节
访问控制符：
public：公有的
protected：受保护的,不能被外部访问，可由子类访问
private：私有的，只能自己类访问，不能通过继承访问
*/
class class1{
public $name;
protected $age;
private $addr;
function __construct($name,$age,$addr){
$this->name=$name;
$this->age=$age;
$this->addr=$addr;
}
function test(){
echo $this->name.'<br .>'; //在类中可以访问受限制的属性
echo $this->age.'<br .>';
echo $this->addr.'<br .>';
}
}
$p1=new class1('php',20,'CQ');
$p1->test(); //php 20 CQ
echo $p1->name; //php 在外部,只能访问公有的属性
echo $p1->age; // 在外部，不能访问类中受限制的属性 Fatal error: Cannot access protected property class1::$age
echo $p1->addr; //Fatal error: Cannot access private property class1::$addr
?>五、__get和__set魔术方法
<?php
#__get() 当在类外部对私有的或受保护的或未定义的成员属性进行读取时会被调用
#__set() 当在类外部对私有的或受保护的或未定义的成员属性进行赋值时会被调用
class class1{
public $name='php';
protected $age=20;
private $addr='CQ';
public function __get($var_name){
echo 'this is __get()';
return $this->$var_name;
}
public function __set($var_name,$var_value){
echo 'this is __set()';
$this->$var_name=$var_value;
}
}
$p1=new class1();
//echo $this->age; //在类外部不能直接访问类中受限或私有的属性
echo $p1->age; //this is __get() 20
$p1->age=18; //this is __set()
echo $p1->age; //this is __get() 18
?>六、__isset()和__unset()
<?php
//可利用此魔术方法限制不可销毁或检测的属性
header('content-type:text/html;charset=utf-8');
class class1{
private $name='php';
private $age=20;
private $addr='CQ';
public function __isset($var_name){
echo '当类外部调用isset()或empty()检测不可访问的属性或未定义的属性时自动调用此函数';
return isset($this->$var_name);
}
public function __unset($var_name){
echo '当类外部调用unset()函数销毁不可访问的属性或未定义的属性时自动调用此函数';
unset($this->$var_name);
}
}
$p1=new class1();
isset($p1->name); //当类外部调用isset()或empty()检测不可访问的属性或未定义的属性时自动调用此函数
isset($p1->ddddd); //当类外部调用isset()或empty()检测不可访问的属性或未定义的属性时自动调用此函数
unset($p1->name); //当类外部调用unset()函数销毁不可访问的属性或未定义的属性时自动调用此函数
?>七、继承
<?php
#子类可以继承父类的属性和方法，但是PHP是单继承
class Person{ //定义一个父类
public $name;
public $age;
public function __construct($name,$age){
$this->name=$name;
$this->age=$age;
}
public function getinfo(){
echo $this->name.'----'.$this->age;
}
}
class Person1 extends Person{ //使用关键字extends继承父类
public $addr='CQ'; //子类可以自己增加属性
public function test(){
echo $this->name.'--'.$this->age.'--'.$this->addr; //子类可以调用父类的属性和方法
}
}
$p1= new Person1('PHP',20);
echo $p1->name; //PHP 子类可以使用父类的可访问属性和方法
$p1->test(); //PHP--20--CQ 字类也可以在父类的基础上进行扩展
?>八、parent关键字的作用
<?php
##parent::属性名/方法
class Person{
public $name;
public $age;
public function __construct($name,$age){
$this->name=$name;
$this->age=$age;
}
public function getinfo(){
return $this->name.'--'.$this->age;
}
}
class Person1 extends Person{
public $addr='CQ';
public function getinfo(){
return $this->name.'--'.$this->age.'--'.$this->addr;
}
public function getinfo1(){
$str=parent::getinfo();
/*
parent::getinfo()等同于 return $this->name.'--'.$this->age.'--'.$this->addr;
*/
//如果在子类中有与父类重复调用的代码，可以用parent关键字代替
return $str.'--'.$this->addr;
}
}
$p1=new Person1('PHP',20);
echo $p1->getinfo().'<br />'; //PHP--20--CQ
echo $p1->getinfo1(); //PHP--20--CQ
?>九、final关键字的作用
<?php
#。如果父类中的方法被声明为 final，则子类无法覆盖该方法。如果一个类被声明为 final，则不能被继承。
class class1{
final public function test(){
echo 'hello world';
}
}
class class2 extends class1{
public function test(){ //如果在父类的方法定义了final，在子类中则不能覆盖该方法
echo 'hello php';
}
}
$p1=new class1();
$p1->test();
$p2=new class2();
$p2->test(); //Fatal error: Cannot override final method class1::test()
final class class3{
public $name='aaa';
}
class class4 extends class3{ //Fatal error: Class class4 may not inherit from final class (class3) i
}
$p3=new class3();
?>10、继承中可见性分析
<?php
#在继承中，父类的private私有的修饰符属性和方法， 不能被子类继承。
class class1{
public $name='php';
protected $age=20;
private $addr='CQ';
}
class class2 extends class1{
public function test(){ //子类继承父类时，不能访问父类的private私有属性和方法
echo $this->name; //php
echo $this->age; //20
echo $this->addr; //Notice: Undefined property: class2::$addr
}
}
$p1=new class2();
$p1->test();
#在继承中，子类覆盖父类属性和方法时，不能比父类修饰时严格
#父类如果是public 子类只能为public 父类是private 子类可以为public和protected
class class3 extends class1{
private $name='php1'; //php1
public $addr='AAA'; //Fatal error: Access level to class3::$name must be public (as in class class1)
}
?>11、类中static关键字的使用和调用
<?php
/*
在类中，访问静态属性和方法，不能使用$this来访问。
1、在类中，使用static关键字修饰的属性和方法，不能通过$this来使用，只能使用
类名::属性/方法
seif::属性/方法
2、在类中，使用static关键字修饰的方法中，不能含有$this
*/
class A{
static public $name='PHP';
public $age=20;
public function test(){
//echo $this->name; //在类中，访问static修饰的属性和方法，不能使用$this调用 Strict Standards: Accessing static property A::$name as non static
echo self::$name; //PHP 只能使用seif::属性/方法
}
static public function test1(){
//echo $this->age; //在static修饰的方法中，不能使用$this Fatal error: Using $this when not in object context
}
}
$p1=new A();
$p1->test();
$p1->test1();
echo A::$name; //PHP 在类外部，可以不通过实例化对象，使用类名::属性/方法来调用
?>12、后期静态绑定 static::属性/方法
<?php
#self::属性/方法 表示当前父类中的属性和方法
#static::属性/方法 表示当前类中的属性和方法
class A{
static public $name='PHP';
public function test(){
echo self::$name; //PHP
echo static::$name; //JAVA
}
}
class B extends A{
static public $name='JAVA';
}
$p1=new B();
$p1->test();
?>13、类常量-const
<?php
#在类中，使用const关键字定义 “常量属性”
#注意，定义和使用常量不需要加$符号
class A{
const PI=3.14;
public function test(){
echo self::PI; //3.14
}
}
$p1=new A();
$p1->test();
?>14、抽象类-abstract
<?php
#1、定义的抽象类不能被实例化，只能通过子类继承实现
#2、任何一个类，如果它里面至少有一个方法是被声明为抽象的，那么这个类就必须被声明为抽象的
#3、被定义为抽象的方法只是声明了其调用方式（参数），不能定义其具体的功能实现
#4、继承一个抽象类的时候，子类必须定义父类中的所有抽象方法
abstract class A{
public function test(){
echo 'test....';
}
abstract public function test1();
}
//$p1=new A(); //抽象类不能实例化 Fatal error: Class A contains 1 abstract method and must therefore be declared abstract or implement the remaining methods (A::test1)
class B extends A{
public function test1(){ //继承一个抽象类的时候，子类必须定义父类中的所有抽象方法
echo 'bbbbb';
}
}
$p2=new B();
?>15、对象接口
<?php
/*
1、接口和抽象类类似，定义的方法，子类必须实现。
2、使用interface定义接口，使用implements关键字实现接口
接口必须public公开
3、一个类可以实现多个接口
4、接口可以继承另外的接口，及继承多个接口
*/
interface A{ //定义一个接口 使用interface关键字
public function test(); //定义接口的方法，和抽象类一样，不需要实现方法具体内容
public function test1($name); //接口也可以定义属性
}
class class1 implements A{ //定义一个类实现接口A 使用implements关键字
public function test(){ //必须实现接口中定义的方法
echo 'A接口中的test方法';
}
public function test1($name){
echo 'A接口中的test1方法'.$name;
}
}
interface B{
public function test2();
}
class class1 implements A,B{ //一个类可以实现多个接口
public function test(){
echo 'A接口中的test方法';
}
public function test1($name){
echo 'A接口中的test1方法'.$name;
}
public function test2(){
echo 'B接口中的test2方法';
}
}
interface C extends A,B{ //接口可以继承另外的接口，及继承多个接口
public function test4();
}
?>