1. 类(对象抽象化的结果)与对象 (类实例化结果)

1、对象是具体存在的事物，对象是由属性（变量）和方法（函数）组成的
2、类是具有相同属性和行为的一组对象的集合
创建类
语法：
class 类名{ //属性 //方法 //常量}
类是由属性、方法、常量组成的，也可以说
类成员有：属性、方法、常量
类名的命名规则：
以字母、下划线开头，后面跟的是字母、数字、下划线
不能用PHP关键字做类名
类名不区分大小写（变量名区分，关键字、类名不区分大小写）
类名用帕斯卡命名法（大驼峰 单词的首字母大写
对象实例化
通过new关键字来实例化对象。

2. 构造方法

构造方法也叫构造函数，当实例化对象的时候自动执行。 语法：
function __construct(){}
注意：前面是两个下划线
构造函数作用：初始化成员变量
注意：构造函数可以带参数，但不能有return。

  1. class Student
  2. {
  3.     private $name;
  4.     private $sex;
  5.     //构造函数初始化成员变量
  6.     public function __construct($name,$sex)
  7.     {
  8.         $this->name=$name;
  9.         $this->sex=$sex;
  10.     }
  11.     //显示信息
  12.     public function show()
  13.     {
  14.         echo "姓名：{$this->name}<br>";
  15.         echo "性别：{$this->sex}<br>";
  16.     }
  17. }
  18. //实例化
  19. $stu=new Student('tom','男');
  20. $stu->show(); //输出 姓名：tom 性别：男

3. 对象成员之间的内部访问 $this

$this表示当前对象的引用，也就是$this保存的当前对象的地址

  1. class A
  2. {
  3.     public $sttr;
  5.     public function getSttr()
  6.     {
  7.         return $this->sttr;
  8.     }
  9. }
  11. $a = new A();
  12. $a->sttr = '属性';
  13. echo $a->getSttr();  //输出 属性

4. private仅限本类中使用 protected本类中,子类中使用

访问修饰符
用来控制成员的访问权限

修饰符描述
public（公有的）在类的内部和外部都能访问
private（私有的）只能在类的内部访问
protected（受保护的）在整个继承链上访问

一般来说，属性都用私有的，通过公有的方法对私有的属性进行赋值和取值。

  1. class Animal
  2. {
  3.     // 公有
  4.     public $name;
  5.     // 保护
  6.     protected $type;
  7.     // 私有
  8.     private $dna;
  9.     // 构造方法
  10.     public function __construct($name,$type,$dna)
  11.     {
  12.         $this->name = $name;
  13.         $this->type = $type;
  14.         $this->dna = $dna;
  15.     }
  16.     // 公有方法对私有属性取值
  17.     public function getDna()
  18.     {
  19.         return $this->dna;
  20.     }
  21. }
  23. // 子类extend继承
  24. class Dog extends Animal
  25. {   // 子类未定义构造方法,默认调用父类的
  26.     // 子类通过公有方法对保护属性取值
  27.     public function getType()
  28.     {
  29.         return $this->type;
  30.     }
  32.     public function getDna()
  33.     {
  34.         parent::getDna();
  35.     }
  36. }
  37. // 子类对象
  38. $husky = new Dog('哈士奇','husky','002001');
  40. echo $husky->name;  //输出 '哈士奇'
  41. //echo $husky->type;  //错误
  42. //echo $husky->dna;   //错误
  43. echo $husky->getDna();  // 无输出,子类拿不到父类的私有
  44. echo $husky->getType();  // 输出 husky
  45. // 父类对象
  46. $cat = new Animal('mimi','cat','001');
  47. echo $cat->getDna();  // 输出002

5. 类的自动加载 spl_autoload_register

类的规则
一个文件中只能放一个类（必须）
文件名和类名同名（必须）
类文件以.class.php结尾（不是必须

  • 手动加载类
    require ‘类文件路径’

  • 自动加载类

    当缺少类的时候自动的调用autoload()函数，并且将缺少的类名作为参数传递给autoload()。

  1. function __autoload($class_name)
  2. {
  3.     require $class_name.'php';
  4. }
  • 注册加载类
    通过spl_autoload_register($callback)注册__autoload()函数
  1. spl_autoload_register(function ($class_name)
  2. {
  3.     require $class_name.'.php';
  4. }
  5. );

可以注册多个自动加载函数

  1. spl_autoload_register('load1');
  2. spl_autoload_register('load2');
  3. spl_autoload_register('load3');
  5. function load1($className)
  6. {
  7.     require $className.'.php';
  8. }
  10. function load2($className)
  11. {
  12.     require $className.'.class.php';
  13. }
  15. function load3($className)
  16. {
  17.     require $className.'.fun.php';
  18. }

6. 静态成员的访问 类的引用self::

static修饰的属性叫静态属性、static修饰的方法叫静态方法
静态成员加载类的时候分配空间，程序执行完毕后销毁
静态成员在内存中就一份。
调用语法 类名::属性 类名::方法名()
self表示所在类的类名，使用self降低耦合性

  1. class Cat
  2. {
  3.     //静态属性
  4.     static $type;
  5.     //静态方法设置静态属性
  6.     public static function setType($type)
  7.     {
  8.         self::$type = $type;
  9.     }
  10.     //静态方法获得静态属性
  11.     public static function getType()
  12.     {
  13.         return self::$type;
  14.     }
  15. }
  17. Cat::$type = '波斯猫';
  18. echo Cat::$type;  //输出 波斯猫
  19. Cat::setType('招财猫');
  20. echo Cat::getType();  //输出 招财猫

7. 类的继承 扩展 父类方法(魔术方法,普通方法)的重写 parent:: 调用父类成员

  1. 继承介绍
    继承使得代码具有层次结构
    子类继承了父类的属性和方法，实现了代码的可重用性。
    使用extends关键字实现继承
    父类和子类是相对的
    语法 :
    class 子类 extends 父类{ }
  2. 子类中调用父类成员
    1、方法一：通过实例化父类调用父类的成员
    2、方法二：通过$this关键字调用父类的成员
  3. protected
    protected：受保护的，在整个继承链上使用
  4. 继承中的构造函数
    规则：
    1、如果子类有构造函数就调用子类的，如果子类没有就调用父类的构造函数。
    2、子类的构造函数调用后，默认不再调用父类的构造函数
    可通过parent调用父类的构造函数
    parent::__construct()
  5. $this详解
    $this表示当前对象的引用，也就是$this保存的当前对象的地址
  6. 多重继承
    PHP不允许多重继承，因为多重继承容易产生二义性
    如何实现C继承A和B，使用继承链
  1. // 父类
  2. class Human
  3. {
  4.     public $name;
  6.     public function __construct($name)
  7.     {
  8.         $this->name = $name;
  9.     }
  11.     public function say()
  12.     {
  13.         return $this->name.' say: hello!';
  14.     }
  15. }
  16. // 子类
  17. class Chinese extends Human
  18. {
  19.     private $nationality = 'CN';
  20.     private $ethnicity;
  22.     public function __construct($name,$ethnicity)
  23.     {
  24.         // 调用父类构造方法后, 加入自
  25.         parent::__construct($name);
  26.         $this->ethnicity = $ethnicity;
  27.     }
  29.     // 重写父类say方法
  30.     public function say()
  31.     {
  32.         return parent::say() . "你好?";
  33.     }
  34.     // 获得属性
  35.     public function getAttr()
  36.     {
  37.         return "国籍:{$this->nationality},民族:{$this->ethnicity}";
  38.     }
  39. }
  40. // 实例化子类
  41. $people = new Chinese('张三', '汉');
  43. echo $people->name; //输出  张三
  44. echo $people->say();  //输出 张三say:hello!你好?
  45. echo $people->getAttr(); //输出  国籍:CN,民族:汉

更多相关文章

  1. php之类与继承
  2. 谈谈使用JS库解决小程序跨页传递消息和数据问题的方法
  3. 5.不确定性推理方法: 可信度方法, 证据理论
  4. 3.分治算法的设计思想与分析方法: 芯片测试, 快速排序, 幂乘算法
  5. PHP基础知识：PHP代码书写规范及数组遍历方法
  6. 就是要让你彻底学会 @Bean 注解
  7. 来探讨一下最近面试问的ThreadLocal问题
  8. 面试官：你能谈谈Dubbo SPI扩展原理吗？
  9. RocketMQ入门到入土（五）消息持久化存储源码解析

随机推荐

  1. android 页面布局时定义控件ID时@id/XX和
  2. Android Application Fundamentals——An
  3. Android中字体的处理
  4. Android Studio 配置快捷方式生成JNI头文
  5. android配置文件详解
  6. Android的BUG（四） - Android(安卓)app的卡
  7. Android数据的四种存储方式
  8. Android so减包相关
  9. Android锁屏控制
  10. Android 报错处理：Android resource linki