面向对象知识点

主要介绍了PHP面向对象程序设计方法,结合实例形式详细分析了PHP面向对象程序设计中所涉及的类的概念、定义、构造函数、析构函数、继承、重写,$this和::需要的朋友可以参考下

一、概念

面向对象编程（Object Oriented Programming，OOP）是一种计算机编程架构，它能使代码更加简洁，更易于维护，并且具有更强的可重用性。

二、定义类

定义：类的变量 属性的声明有： private > protected > public 数据类型：1、基本数据类型（整型int、浮点型float、字符串string、布尔bool）；2、复合数据类型（数组array、对象object）；3、特殊数据类型（null、资源）

class 类名 { }   //类首字母大写

三、定义属性和方法

公有的 public

public $name;

受保护的 protected

protected $age;

私有的 private

private $id;

1、方法

public function study(){
echo "在学习";
}

四、访问属性和方法

1、访问属性

需要先实例化对象 new

$opp = new 类名;
$opp -> study(); //调用访问方法

2.方法的参数

public function study(){
...
}

3.方法默认值

public function study($name="小明"){
     echo $this -> name;
}

4.方法返回值

return '需要返回的值'；

五、修改属性的值

1.直接修改

public $name="要修改的值";

2.使用方法修改$this

$this -> name="要修改的值";

六、权限修饰符

公有的 public 
私有的 private 
受保护的 protected 

七、构造方法

public function _ _construct(){
     ...
}

八、析构方法

public function __destruct(){
 // 释放该对象的资源
}

九、继承

可继承父类的成员变量，允许定义父类没有的成员变量。

关键字 extends
格式 class 类名 extends 需要继承的类{
...
}

1.单继承

PHP是单继承的，一个扩充类只能继承一个基类，但一个父类却可以被多个子类所继承。子类不能继承父类的私有属性和私有方法。在PHP 5之后的版本中，类的方法可以被继承，类的构造函数也能被继承。当子类被实例化时，PHP会先在子类中查找构造方法，如果子类有自己的构造方法，PHP会优先调用子类中的构造方法；当子类中没有时，PHP会转而去调用父类中的构造方法。

class Person //定义人类
{
    public $name; //定义姓名
    protected $age; //定义年龄
}
class Man extends Person  //定义男人类并继承人类的成员变量
{
    public $sex;  //定义父类没有的成员变量
    public function sayName(){ //成员方法
       echo $this -> $name="小红"; //输出继承的姓名
 }
}
$people = new Man(); //实例化对象
$people -> sayname(); //访问成员方法

2.重写

如果从父类继承的方法不能满足子类的需求，可以对其进行改写，该过程叫做方法的覆盖（override），也称为方法的重写。在对父类的方法进行重写时，子类中的方法必须与父类中对应的方法具有相同的名称。

重写时方法的权限修饰符不能比父类严格

<?php
class person
{
    public $name;
    public function  __construct(){
        $this->name="小娃";
    }
    public function sayName(){
        echo "我是小娃";
    }
}
class Student extends person
{
    public $student_number;
    public function sayName() //重写父类的方法
    {
        echo "我是小洋";
    }
}
$person = new Student();
$person ->sayName();

十、$this->和::的使用

1、this

系统会给每个对象分配this，代表当前对象 this 只能在类内部方法中使用，不能在类定的的外部使用。

$this->name;
$this->name=" ";

2、::

相对只能在类内部使用的伪变量$this->来说，操作符“::”更为强大。它可以在没有声明任何实例的情况下访问类中的方法或变量。其使用格式如下：

关键字::变量名/常量名/方法名
parent::study(); //调用父类的study方法

此处的关键字可以为以下3种情况。
parent：用于调用父类中的成员变量、成员方法和常量。
self：用于调用当前类中的静态成员和变量。
类名：用于调用本类中的变量、常量和方法。

<?php
class person
{
    public $name;
    public function  __construct(){ //构造函数
        echo 1;
    }
}
class Student extends person
{
    public function __construct()
    {
        person::__construct(); //调用父类的构造函数
        echo 2;
    }
}
$person = new Student(); //实例化子类

输出结果为12

十一、静态变量（方法）

1、static 关键字

static关键字的作用是将类的成员属性或成员方法标识为静态的

类调用：名::静态成员属性名;
类调用：类名::静态成员方法名();
对象调用：对象名::静态成员属性名;
对象调用：对象名::静态成员方法名;

<?PHP
  class People
  {
    public static $age=19;  //定义静态成员属性
    public static function getAge()
    {
      echo "调用静态方法";
    }
  }
    echo People::$a;   //People 类调用属性,输出结果为19。不需要实例化
    echo People::getAge(); // People 类调用方法,不需要实例化,输出结果为 "调用静态方法"
    $example = new People(); //实例化一个对象
    echo $example::$a;      //实例化的对象调用属性 输出结果为19
    echo $example::getAge(); //实例化对象调用方法 输出结果为  "调用静态方法"

?>

2、self

访问静态变量

class Person4
{
    // static 表示静态的
    public static $age = 21;
    public $age2 = 30;

    public function getAge()
    {
        // 在类内访问静态的成员变量
        echo self::$age;
        self::$age++;
        echo '<br />';
    }

    // 定义静态方法
    // 在静态方法中不能用 $this
    public static function getAge2()
    {
        echo '我的年龄是：' . self::$age;
        echo '<br />';
    }
}

十二、final

如果父类中的方法被声明为final，则子类无法覆盖该方法，如果一个类被声明为final，则不能被继承

final class People{  //使用final标记的类，不能被继承，不能有子类
 ...
}

class People{
 final function Man(){  // 在类中使用final标记的方法，在子类中不可以重写和覆盖
 ...
 }
}

十三、const 常量

const是一个定义常量的关键字。调用const 常量和静态成员(static)是一样的。在类外通过类名访问，在成员方法中使用self关键字进行访问。注：const标识的常量是一个恒值，不能重新赋值，所以一定要在定义的时候初始化。使用 const 声明的常量名称前不能使用$符号，并且常量名通常是大写。

class Person 
{
  const NUMBER=123;//定义常量
  public function Man()
  {
    echo self::NUMBER; //在类内调用常量NUMBER
    echo Person::NUMBER; //也可以写为类名::常量
 }
}
$a= new Person(); //实例化对象
$a ->Man(); //访问成员方法

十四、抽象类和抽象方法

abstract

1、抽象类

abstract class Person //使用abstract标记的类，不能被实例化
{
  static  public  $age=19;
}
 echo People1::$age; // 可以访问静态变量

2、抽象方法

只要类中存在一个抽象方法，那这个类就必须为抽象类，方法抽象后在子类必须重写

// abstract 声明抽象类
// 抽象类不能被实例化，只能作为其它类的父类来使用
// 只要一个类中存在一个抽象方法，该类就必须为抽象类
abstract class People1
{
    public  $age=19;
    public abstract function getAge();  // 声明抽象类中的抽象方法,抽象方法不能有方法体。
}
class Person1 extends People1
{
    public  function getAge() // 子类当中必须重写父类中所有的抽象方法
    {                          // 重写的方法权限只能更宽松
        echo 2;
    }
}
$a= new Person1();
$a->getAge();

十五、魔术方法

1、__set()

在给不可访问属性赋值时，__set() 会被调用 语法为__set($name,$value)。 参数$name是指要操作的变量名称

    // 给一个未定义的属性赋值时
    // 两个参数均不能省略
   class Magic
   { 
         public function __set($name, $value)
     {
         echo '__set()执行，';
     }
   }
   $test = new Magic();
   $test->name="小娃"; //给未定义属性赋值 调用__set()

2、__get()

当读取不可访问属性的值时，__get()会被调用 语法为 __get($name) $name指要操作的变量名称

class Magic
{
    // 当调用一个未定义或不可见（私有）的成员变量时
    private $age=19;
    public function __get($name) 
    {
        echo '__get()执行';
    }
}
    $test = new Magic();
    $test->name;  //读取不可访问的成员变量的值 调用__get()
    $test->age;   //读取私有的成员变量的值 调用__get()

3、__call()

当读取不可访问属性的值时，__call()会被调用 语法为 __call($name,$params) $name指要操作的变量方法 $params为数组

class Magic
{
    // 当调用不存在或不可见的成员方法时
    public function __call($name, $params)
    {
        echo '__call()执行';
        echo '你调用了不存在的方法：' . $name;
        echo '<br />';
        echo '传递的参数为:';
        print_r($params);
    }
}
     $test = new Magic();
     $test->name(1,2); //访问不存在的成员方法 调用__call() 也可用于访问私有的成员变量

3、__toString()

class Magic
{
     public function __toString()
    {
        return "123";
    }
}
   $test = new Magic();
   echo  $test;