PHP面向对象

什么是面向对象？

准确的说面向对象编程我们叫 OOP，面向对象的编程分为三部分：面向对象分析（Object Oriented Analysis,OOA）、面向对象设计（Object Oriented Design,OOD）,以及面向对象编程（Object Oriented Programming）。面向对象编程的两个中个重要的概念是类和对象。

面向对象的三大特征

  • 封装性
    把相同的属性和方法抽象成一个类叫做封装
  • 继承性
    子类继承父类的属性和方法叫做继承。我们可以重写和添加新的属性方法。在PHP 中支持的是单继承。一个子类有且只有一个父类。
  • 多态性
    同一个类的不同对象,调用同一个方法可以获得不同的结果叫多态(增强程序的灵活性和重用性）

PHP 对象

类的定义

PHP 通过 class 关键字加类名来定义类

<?php
class Person{

}
?>

成员方法

类中的函数被称为成员方法

<?php
class Person{
    function man(){
  
  }
}

?>

类的实例化

通过 new 关键字 实例化对象，通过对象->成员方法 来调用成员方法。

class Per{
    function man($name, $age)
    {
        echo $name;
        echo $age;
    }
}
$m1 = new Per();
echo $m1->man('小明','22');

成员变量

类中的变量，也称为成员变量。有些人也把它叫做属性或者字段。成员变量的是用来保存数据信息。(访问成员变量和成员方法的方法一样，对象->成员变量)
定义成员变量和成员方法：

<?php
class Per{
    // 声明成员变量
    // 关键字（修饰符） 成员变量名
    // 关键字有public ,private, protected, static
    public $name;
    public $age;
    public $money;
    public function man($name, $age,$money){
        echo $name.'今年'.$age.'工资是'.$money;  
    }
}
$m1 = new Per();
$m1->man('小明',22,4000);
?>

类常量

常量是不可改变的量,是一个恒值,举例圆周率就是一个常量。使用关键字 const定义常量。

class Per{
    // 通常常量用大写字母
    const WORK='搬砖';
}
echo Per::WORK;

构造函数和析构函数

构造函数

当一个类实例化为一个对象的时候，可能可能会随着对象的初始化而初始化一些成员变量。就是给一些成员变量赋值。这种情况下我们就可以使用构造函数。因为对象实例化过程中构造函数是自动执行的。

析构函数

析构函数的作用和构造方法方法刚好相反，是对象被销毁时被调用的，作用是释放内存。

<?php
class Person
{
    // 公共成员变量名
    public $name;
    public $age;
    public $sex;
    public $type = "人类";

    // 构造函数 
    // 原来给成员变量赋值 
    // 在对象开始实例化的时候 自动执行
    public function __construct($name, $age, $sex)
    {
        $this->name = $name;
        $this->age = $age;
        $this->sex = $sex;
    }
    //析构函数 在对象被销毁的时候 自动执行
    public function __destruct()
    {
        echo "$this->type.对象被销毁,已释放";
    }
}
$p1 = new Person('小龙', 18, 0);
print_r($p1);

继承和多态

继承

子类继承父类的所有成员变量方法，包括构造方法，当子类被实例化的时候，PHP 会先在子类当中找构造方法，如果子类已经有自己的构造方法。PHP 会先调用子类的方法。当子类当中没有的时候，PHP 才会去调用。父类当中的构造方法，这就是继承。

<?php
class Person
{
    // 公共成员变量名
    public $name;
    public $age;
    public $sex;
}
// 继承
// 将person当成父类
// man继承父类 person 的属性和方法
class Man extends Person
{
    public function money()
    {
        echo '小龙赚钱';
    }
}
$m1 = new  Man('小刘', 23, 1);
$m1->money();
多态
<?php

class Animal
{
    public $name;
    public $sound;

    public function say(){
      echo  $this->sound;

    }
    public function __construct($name1,$sound){
        $this->name=$name1;
        $this->sound=$sound;
    }
}
 class Dog extends Animal{
}
class Cat extends Animal{ 
}
class Sheep extends Animal{  
}
function asay($obj) {
$obj->say();
}
$m1=new Dog('猫猫','喵喵');
$m2=new Cat('狗狗','汪汪汪');
$m3=new Sheep('羊羊','咩咩咩');
asay($m1);
asay($m2);
asay($m3);

操作符

PHP通过为变量this->和域的操作符"::"来访问自己的成员变量和成员方法

  • this->
    在类内部我们可以通过this访问当前实例化对象，调用方法或成员变量的话则使用 "this->成员变量" 、 "this->成员方法" 来访问。所以 this-> 只在类的内部使用
    -操作符::
    $this只能在类的内部去使用。操作符"::"可以在没有声明任何实例的情况下，访问类当中的成员方法或成员变量。(关键字::变量名/常量名/方法名
    )
    parent： 可以调用父类中的 成员变量，成员方法和常量
    self：可以调用当前类中的 静态成员和常量
    类名：可以调用本类中的静态变量，常量和静态方法
<?php
//A 类
class A
{
    const Type = 0;
    const NAME = "A";
    function a(){
        // echo self::Type.self::NAME;//0,A
        // echo "<br>";
    }
}

class B extends A
{
    // 子类独有的方法
    const Type = 1;
    const NAME = "B";
    public function a()
    {
        // echo parent::Type .parent::NAME;//0,A
        // echo "<br>";
        // echo self::Type.parent::NAME;//1,A
    }
}
$a1 = new  A();
$b1 = new  B();
$a1->a();
$b1->a();

修饰符

public、private、protected、static和final。这些关键字是用来限定类成员（包括方法和变量）的访问权限。

public（公共成员）
  1. 在类的内部 可以使用
  2. 在类的外部 可以使用
  3. 在子类的内部 可以使用
<?php
class Per
{
    public $name = "小龙";
    public function fn()
    {
        // 1.可以在类的内部访问，对当前类的 内部可见
        echo $this->name;
    }
}

class Students extends Per
{
    public function fn1()
    {
        // 2.可以在子类的内部访问，对子类的内部可见
        $this->fn();
    }
}
// 3.在类的外部可见
echo $s1->name;
$s1 = new Per();
// $s1->fn();//在类的内部访问
$s2 = new Students();
// $s2->fn1();//可以在子类的内部访问
private（私有成员）

1.在类的内部 可以使用
2.在子类的内部 不能使用
3.在类的外部 不能使用

class Book{
    private $name='HTML';
    public function setName($name){
        // 1.在当前类内部 可访问
        $this->name=$name;
        echo $name;
    }
    public function getName(){
        echo $this->name;
    }
    private function c1(){
        echo '123';
    }
}

class Histoty extends Book{
    public function getBookName(){
        // 2.在子类内部不可见 不可访问继承来的父类中的私有成员变量 私有方法
        echo $this->name;
        // $this->c1();
    }
}
$b1=new Book;
// $b1->setName('测试');//在当前类内部 可访问
// 3.在类的外部不可访问 私有成员变量或私有成员方法
// echo  $b1->name;//在类的外部 不能访问
// $b1->name='js';//在类的外部 不能使用
$h1=new Histoty();
$h1->getBookName();//在子类的内部 不能使用
protected（保护成员）
  1. 在类的内部 可以使用
  2. 在子类的内部 可以使用
  3. 在类的外部 不能使用
<?php
class Per{
    protected $money=100000;
    public function fn(){
        echo $this->money;
        // 1.在当前的内部可以访问
    }
}
class Xs extends Per{
    public function fn1(){
        echo $this->money;
        // 2. 可以在子类的内部访问
    }
}
// 3. 在类的外部不能直接访问，
$p1=new Per();
// $p1->fn();//在类的内部 可以使用
// echo $p1->money;//在类的外部 不能使用
$s1=new Xs();
$s1->fn1();//在子类的内部 可以使用
final 关键字
<?php
// final 被修饰过的类是最终版本
class A{
    public function aa(){
      echo 'aa'  ;
    }
    public function _construct(){
        $this->aa();
    }
}

final class B extends A{

    public function aa(){
        echo "bb";
    }
    // 被final  修饰过的方法 不能在子类中被重写
}
// 被final 修饰过的 类不能被继承
class C extends B{}
$c1= new C();
$c1->aa();
// $b1=new B();
// $b1->aa();//被final  修饰过的方法 不能在子类中被重写

静态成员（变量，方法）

不是所有的方法都要通过创建对象来去调用的，我们可以。通过给变量或者方法加上static关键字来直接调用。也叫做访问静态成员

<?php
class Book{
    static $num=0;//声明一个静态变量$num,初始值为0；
    public function showMe(){
        echo '您是第'.self::$num.'位访客';
        self::$num++;//
    }
}
$b1=new Book();
$b1->showMe();
echo '一共有'.Book::$num.'位访客';
©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成，浏览时请结合常识与多方信息审慎甄别。
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

相关阅读更多精彩内容

  • 6.php面向对象
    面向对象的基本概念 什么是类 类是由相同特征(属性、静态的)和行为(方法、动作)的一组对象构成分类、类型、自定义类...
    dwy_interesting阅读 200评论 0赞 0
  • PHP面向对象
    1 写出 php 的 public、protected、private 三种访问控制模式的区别（新浪网技术部） ...
    叫我峰兄阅读 358评论 0赞 3
  • 4.PHP面向对象
    1. 面向对象的基本概念 1.1 什么是面向对象编程。 准确的说面向对象编程我们叫 OOP.面向对象的编程分为三部...
    默闲阅读 331评论 0赞 2
  • PHP面向对象（三）
    9.魔术方法的应用 __get()方法： 这个方法用来获取私有成员属性值的，有一个参数， 参数传入你要获取的成员属...
    PHPer_阅读 508评论 0赞 1
  • php面试题之二 （PHP面向对象） --- 2021-09-15
    PHP面向对象 写出 php 的 public、protected、private 三种访问控制模式的区别（新浪网...
    一位先生_阅读 435评论 0赞 1

友情链接更多精彩内容