php 类 属性和方法的关系

　　一 . 属性关系

　　　　1 .  public属性：在类的外部和内部都可以调用  被继承能够重构

　　　　2 .  protected属性：在类的内部可以调用外部不能可以被继承并且重构

　　　　3 .  private属性：只有在类的内部调用 不能被继承

　　　　4 .  static属性：类的内部和外部都能调用  内部调用方法（self：：属性变量） 外部调用方法(类名：：属性变量)

　　二 . 方法关系

　　　　1 . public方法：在类的外部和内部都可以调用 可以被继承

　　　　2 . protected方法：在类的内部可以调用外部不能 可以被继承

　　　　3 .  private方法：只有在类的内部调用 不可以被继承

　　　　4 . static方法：外部内部都可以调用  内部调用方法（$this->方法名） 外部调用发法（类名：：方法名）

　　三 . final 说明

　　　　1 . final---用于类、方法前。

　　　　2 . final类---不可被继承。

　　　   3 . final方法---不可被覆盖。

　　 四 . 下面是自己写的测试demo

<?php

    /**
     * DEFINE　MyClass1
     * Date 2019-3-14
     * Author QQ28281633
     */
    class MyClass1
    {
        //声明一个公共的变量
        public $public = ‘Public‘;
        //声明一个受保护的变量
        protected $protected = ‘Protected‘;
        //声明一个私有的变量
        private $private = ‘Private‘;
        function printAll()
        {
            echo $this->public;
            echo $this->protected;
            echo $this->private;
        }
    }

    //实例化对象
    $obj = new MyClass1();
    echo $obj->public;     //正常输出： Public
    echo $obj->protected;  //报错：Cannot access protected property
    echo $obj->private;    //报错：Cannot access protected property
    $obj->printAll();      //正常输出 Public Protected Private

    /**
     * DEFINE　MyClass2
     * Date 2019-3-14
     * Author QQ28281633
     */

    class MyClass2 extends MyClass1{
        // 可以对 public 和 protected 进行重定义，但 private 而不能
        public $public = ‘Public2‘;
        protected $protected = ‘Protected2‘;
        static $a = 1;

        function printAll(){
            echo $this->public;
            echo $this->protected;
            echo $this->private;
        }
    }

    $obj2 = new MyClass2();

    echo $obj2->public; // 这行能被正常执行
    echo $obj2->private; // 未定义 private
    echo $obj2->protected; // 这行会产生一个致命错误
    $obj2->printAll(); // 输出 Public Protected2 和 Undefined

    /**
     *DEFINE MyClass3
     * 类中方法的访问控制
     */

    class MyClass3{
        //声明一个共有的构造函数
        public function __construct(){}

        //声明一个共有的方法
        public function myPublic(){
            return ‘myPublic‘;
        }

        //声明一个受保护的方法
        protected function myProtected(){
            return ‘myProtected‘;
        }

        //声明一个私有的方法
        private function myPrivate(){
            return ‘myPrivate‘;
        }

        //检查输出所有方法
        public function printAll(){
            echo $this->myPublic();
            echo $this->myProtected();
            echo $this->myPrivate();
        }
    }

    $obj3 = new MyClass3;
    echo $obj3->myPublic();     //正常执行
    echo $obj3->myProtected(); //报错
    echo $obj3->myPrivate();  //报错
    $obj3->printAll(); //三个方法在类的内部均可正常执行

    class Tests
    {
        public function test() {
            $this->testPrivate();
            $this->testPublic();
            $this->testStatic();
        }

        public function testPublic() {
            echo "1";
        }

        private function testPrivate() {
            echo "2";
        }

        public static function testStatic(){
            echo 3;
        }
    }

    $myFoo = new Tests();
    Tests::testStatic();
    $myFoo->test();

    /**
     * Class Math
     *  final 解释
     */
    class Math
    {
        public final function max(){
           echo 1;
        }
    }
    //声明类SuperMath 继承自 Math类
    class SuperMath extends Math
    {
        public final function max(){
            echo 2;
        }
    }
    //执行会出错，final方法不能被重写。

?>

原文地址：https://www.cnblogs.com/vinzen/p/10534552.html