search

博客列表 >服务端 - PHP - OOP之类成员定义与访问、类继承和抽象类实现

服务端 - PHP - OOP之类成员定义与访问、类继承和抽象类实现

郴
郴原创
2020年04月30日 15:59:32723浏览

服务端 - PHP - OOP之类成员定义与访问、类继承和抽象类实现

一、类成员

1. 类属性

  • 语法：访问限制符 变量;
  • 描述：带有访问控制的变量
  • 分类：常规属性、静态属性和抽象属性
  • 常规属性：被类实例访问
  • 静态属性：被类访问
  • 抽象属性：没有被赋值，无法实例化，默认值是null，只能通过子类继承实现
  1. echo '<h3>一、常规属性的定义和访问</h3>';
  3. class Person {
  4.     //在类内部定义类的常规属性
  5.     public $name = '小明';
  6.     public static $age = 18;
  8.     public function getName() {
  9.         //在类内部访问类的常规属性
  10.         return $this->name;
  11.     }
  12. }
  14. $p1 = new Person();
  15. //在类外部访问类的常规属性
  16. echo $p1->name;
  17. echo '<br>';
  18. //在类内部访问类的常规属性
  19. echo $p1->getName();
  21. echo '<h3>二、静态属性的定义和访问</h3>';
  23. class Person1 {
  24.     public $name = '小红';
  25.     //在类内部定义类的静态属性
  26.     public static $age = 17;
  28.     public function getAge() {
  29.         //在类内部访问类的静态属性
  30.         return self::$age;
  31.     }
  32. }
  33. $p2 = new Person1();
  34. //在类外部访问类的静态属性
  35. echo $p2::$age;
  36. echo '<br>';
  37. //在类内部访问类的静态属性
  38. echo $p2->getAge();

2. 类方法

  • 语法：访问限制符 函数;
  • 描述：带有访问控制的函数
  • 分类：常规方法、静态方法和抽象方法
  • 常规属性：public/protected/private
  • 静态属性：static。直接用类调用，被所有类实例所共享
  • 抽象属性：没有方法体
  1. echo '<h3>一、常规方法的定义和访问</h3>';
  3. class Person {
  4.     public $name = '小明';
  5.     public static $age = 18;
  6.     //在类内部定义类的常规方法
  7.     public function getName() {
  8.         return $this->name;
  9.     }
  10.     public function sayName() {
  11.         //在类内部调用类的常规方法
  12.         echo $this->getName();
  13.     }
  14. }
  16. $p1 = new Person();
  17. //在类外部调用类的常规方法
  18. echo $p1->sayname();
  19. echo '<br>';
  21. echo '<h3>二、静态方法的定义和访问</h3>';
  23. class Person1 {
  24.     public $name = '小红';
  25.     public static $age = 17;
  27.     //在类内部定义类的静态方法
  28.     public static function getAge() {
  29.         return self::$age;
  30.     }
  31.     public static function sayAge() {
  32.         //在类内部调用类的静态方法
  33.         echo self::getAge();
  34.     }
  35. }
  36. $p2 = new Person1();
  37. //在类外部调用类的静态方法
  38. echo $p2::sayAge();
  39. echo '<br>';
  41. echo '<h3>三、在类方法中访问外部成员</h3>';
  43. $name = '小王';
  44. $age = 19;
  45. $sayName = function() {
  46.     global $name;
  47.     return '我的名字叫'.$name;
  48. };
  50. class Person2 {
  51.     public function hello($v, $a) {
  52.         return $v(). '，'.'我的年龄是'.$a;
  53.     }
  54. }
  56. $p3 = new Person2;
  57. echo $p3->hello($sayName, $age);

3. 类常量

  • 语法：const 常量名;
  • 描述：在类中始终保持不变的值

二、类继承

  • 语法：class 类名 extends 基类名;
  • 二类成员：子类有权访问的父类成员类型，public和protected
  • 三种操作：子类对父类的三种操作，继承、重写和扩展
  • 继承：父类的二类成员自动成为子类的成员
  • 重写：覆写与父类/基类同名的成员（属性，方法）
  • 扩展：子类添加自身的方法来增加/扩展父类的功能
  1. /*
  2. * 时间：2020年4月30日10:42:47
  3. * 知识点：重写类属性和类方法
  4. * 场景：重写父类的方法并对其进行拓展
  5. */
  7. echo '<h3>类的继承</h3>';
  9. class Person {
  10.     //定义公共的类属性
  11.     public $name;
  12.     public $sex;
  13.     public $age;
  15.     public $test = 1;
  16.     //使用一个公共方法初始化类属性
  17.     public function setInfo($name, $sex, $age)
  18.     {
  19.         $this->name = $name;
  20.         $this->sex = $sex;
  21.         $this->age = $age;
  22.     }
  23.     //定义一个公共方法来获取类属性
  24.     public function getSelf() {
  25.         return  $this->name.$this->sex.$this->age;
  26.     }
  27. }
  29. $p1 = new Person;
  30. $p1->setInfo('小明', '男', 18);
  31. echo $p1->test;
  32. echo $p1->getSelf();
  33. echo '<br>';
  35. //定义一个子类
  36. class Student extends Person {
  37.     //重写父类的属性
  38.     public $test = 2;
  40.     public $school = '北京三中';
  42.     //重写父类的saySelf方法
  43.     //并在该方法中使用parent关键字调用父类被覆盖的saySelf方法
  44.     //如果需要父类saySelf方法中的完整代码而又要避免在该方法中对其复制粘贴，因为这样会导致代码冗余
  45.     public function getSelf() {
  46.         return  parent::getSelf().$this->school;
  47.     }
  49.     //扩展父类的方法
  50.     public function saySchool() {
  51.         echo '我在'.$this->school.'读书';
  52.     }
  53. }
  55. $p2 = new Student;
  56. $p2->setInfo('小红', '女', 17);
  57. echo $p2->test;
  58. echo $p2->getSelf();
  59. echo '<br>';
  60. $p2->saySchool();

三、抽象类

  • 语法：abstract class 类名;
  • 特点：
序号 描述
1 抽象类也叫设计类
2 不能被实例化
3 只要类中有一个抽象方法，那么这个类就是抽象类
4 抽象类中允许有抽象成员，但不是强制的，也可以没有，类中也可以定义普通方法
5 必须实现类中的抽象方法才可以实现此抽象类
6 抽象类可以被继承
  • 作用：实现部分分离“设计（抽象类中完成）与实现（工作类中完成）”
  • 场景：接口实现
  • 抽象方法：没有方法体，不能定义其具体的功能实现
  • 抽象方法定义：abstract 访问控制 函数名;
  • 抽象类的继承：继承一个抽象类的时候，子类必须定义父类中的所有抽象方法，这些方法的访问控制必须和父类中一样（或者更为宽松）
  1. echo '<h3>抽象类的实现</h3>';
  3. //设计类实现
  4. abstract class aPerson {
  6.     protected static $name;
  7.     protected static $sex;
  8.     protected static $age;
  10.     abstract protected function getInfo();
  11. }
  13. //工作类实现
  14. class Student extends aPerson {
  16.     protected $school;
  18.     public function setInfo($name, $sex, $age, $school) {
  19.         self::$name = $name;
  20.         self::$sex = $sex;
  21.         self::$age = $age;
  22.         $this->school = $school;
  23.     }
  25.     public function getInfo() {
  26.         return self::$name.self::$sex.self::$age.$this->school;
  27.     }
  28. }
  30. //客户端调用
  32. $user = new Student;
  33. $user->setInfo('小明', '男', 18, '北京三中');
  34. echo $user->getInfo();

四、课程总结

  • 今天学习了 PHP 的面向对象编程，通过上课认真听讲和认真完成老师布置的作业，使得我对 PHP 面向对象编程的理解和运用更加深入和熟悉。最主要的知识点是明白和掌握了类成员的定义和访问，单继承、以及抽象类的特点和基本用法。
上一条：php接受不到ajax的post数据下一条：php 运算符 、流程控制
声明：本文内容转载自脚本之家，由网友自发贡献，版权归原作者所有，如您发现涉嫌抄袭侵权，请联系admin@php.cn 核实处理。
全部评论
文明上网理性发言，请遵守新闻评论服务协议

相关文章

查看更多