1. 本类的实例访问本类

1. 本类的实例访问本类

1.1 本类实例访问本类的一非静态属性

<?php
class Father
{
    public $a = 'a 属性';
    protected $b = 'b 属性';
    private  $c = 'c 属性';
}
$fa = new Father();
echo ($fa->a) . '<br>'; // a属性
echo ($fa->b) . '<br>'; // 无法访问 受保护的属性
echo ($fa->c) . '<br>'; // 无法访问 私有的的属性

我们轻易的就发现了一个问题，那就是类的实例只能访问类的公共方法。其实仔细一想这一点也很好理解啊。public 修饰的是一个公共的它是可以随意在类的外部被访问到的。_protected 受保护的：可以在当前类和当前类的子类中访问。可没有说的是类的外部。private就更不用说了，我们如果想要在类的外部访问 protected、private修饰的方法。我们通常这样做：在类的内部提供一个公有的方法_，我们通过这个公有的方法来获取。
如下面的代码：我们利用的是在类中，我们可以轻易的获取任何权限修饰的属性或者方法

<?php
class Father
{
    public $a = 'a 属性';
    protected $b = 'b 属性';
    private  $c = 'c 属性';
    public function getPropertyB()
    {
        return (new Father())->b;
    }
    public function getPropertyC()
    {
        return (new Father())->c;
    }
}
$fa = new Father();
echo $fa->getPropertyB(); // b 属性
echo $fa->getPropertyC(); // c 属性

1.2 本类实例访问本类的一静态属性

对于public修饰的属性或者方法，还是很宽松的。我们在类的外部既可以通过 类名称 :: 类静态属性 来获取，也可以 类实例 :: 类静态属性 来获取。

<?php
class Father
{
    public static $a = 'a 属性';
    protected static $b = 'b 属性';
    private  static $c = 'c 属性';
}
$fa = new Father();
// 子类访问静态属性
echo ($fa::$a) . '</br>';    // a属性
//  类名访问静态属性
echo (Father::$a) . '</br>'; // a属性

同样的如果想是用下面的这种方式去访问，还是不行的。

echo ($fa::$b) . '<br>';
echo (Father::$b) . '<br>';

按照前面的思路，这样去写。PHP中，在类里面我们可以通过三种方式来获取静态属性：1. 类名称 :: 静态属性名称 、2. self :: 静态属性名称 、3. static :: 静态属性名称

<?php
class Father
{
    public static $a = 'a 属性';
    protected static $b = 'b 属性';
    private  static $c = 'c 属性';
    public function getPropertyB() {
        return self::$b;
    }
    public function getPropertyC() {
        return static::$c;
    }
}
$fa = new Father();
echo $fa->getPropertyB() . '</br>'; // b 属性
echo $fa->getPropertyC() . '</br>'; // c 属性

如过你实在是闲的蛋疼，其实也可以在类中使用实例去获取，这不过这还需要去 new

<?php
class Father
{
    public static $a = 'a 属性';
    protected static $b = 'b 属性';
    private  static $c = 'c 属性';
    public function getPropertyB() {
        return (new Father())::$b;
    }
    public function getPropertyC() {
        return (new Father())::$c;
    }
}
$fa = new Father();
echo $fa->getPropertyB() . '</br>'; // 
echo $fa->getPropertyC() . '</br>'; //

1.3 本类实例访问本类的一非静态方法

我发现一个很有意思的事情：我们竟然可以通过静态的方式去访问非静态的方法，但是抛出了不赞成，哈哈

<?php
class Father
{
    public function A()
    {
        echo 'A() is called' . '</br>';
    }
    protected function B()
    {
        echo 'B() is called' . '</br>';
    }
    private function C()
    {
        echo 'C() is called' . '</br>';
    }
}
$fa = new Father();
// 对于A(),我们还是轻易的访问到了
$fa->A(); // A() is called
// 我想让通过静态的方式访问非静态的方法，看下行不行(针对于public这个宽松的条件)
$fa::A(); // Deprecated: Non-static method Father::A() should not be called statically in D:\wamp64\www\JS\6.6\1_3-test.php on line 27

我很好奇，然后我们看看下面的代码。通过下面的代码我们似乎可以得出一个结论。无关乎与访问权限控制符，PHP中我们就是可以用静态的方式去调用非静态的方法，但是这是不赞成的

<?php
class Father
{
    public function A()
    {
        echo 'A() is called' . '</br>';
    }
    protected function B()
    {
        echo 'B() is called' . '</br>';
    }
    private function C()
    {
        echo 'C() is called' . '</br>';
    }
    public function test1() 
    {
        self::A();
    }
    public function test2() 
    {
        self::B();
    }
    public function test3() 
    {
        self::C();
    }
}
(new Father()) -> test1(); // A() is called
(new Father()) -> test2(); // B() is called
(new Father()) -> test3(); // C() is called

回到正题，我们如何在类外部去访问受保护的和私有的非静态方法呢，这不还是同一个道理吗。代码如下

<?php
class Father
{
    public function A()
    {
        echo 'A() is called' . '</br>';
    }
    protected function B()
    {
        echo 'B() is called' . '</br>';
    }
    private function C()
    {
        echo 'C() is called' . '</br>';
    }
    public function callMethodB()
    {
        (new Father())->B();
    }
    public function callMethodC()
    {
        (new Father())->C();
    }
}
$fa = new Father();
$fa ->callMethodB(); // B() is called
$fa ->callMethodC(); // C() is called

1.4 本类实例访问本类的一静态方法

<?php
class Father
{
    public static function A()
    {
        echo 'A() is called' . '</br>';
    }
    protected static function B()
    {
        echo 'B() is called' . '</br>';
    }
    private static function C()
    {
        echo 'C() is called' . '</br>';
    }
    public static function callMethodB()
    {
        self::B();
    }
    public static function callMethodC()
    {
        self::C();
    }
}
// 对于A
Father::A();
// 对于B和C
Father::callMethodB();
Father::callMethodC();

1.5 本类实例访问本类的一常量

这个就只说不写算了。PHP中的类中的常量只可以用 const 关键来定义，在其他地方我们也可以通过define() 函数来定义一个常量，不管是不是在类中去定义一个常量，我们都应该使用const而抛弃define()函数，不仅仅是因为性能存在差异，而且const从命名上就更加直观。
const DA_XIE = 'xxx'; 我们不用加上$这个美元符，也不用加上访问权限控制符（这是因为对象直接访问类常量，也就是说类常量本质上就是给类服务的）。
名称全大写_隔开。
调用的方式：和静态属性一样三种调用方式都可以，不像大部分人垃圾博客说来说去的就说的那两种，也可以是 static :: 常量名称
它是只读的，不可以改，所以定义的时候一定要直接赋予初始值

// 没啥好写的
<?php
class Father
{
    const A = 'A';
    public static function getConstA_1()
    {
        echo static::A . '<br>';
    }
    public static function getConstA_2()
    {
        echo self::A . '<br>';
    }
    public static function getConstA_3()
    {
        echo Father::A . '<br>';
    }
}
Father::getConstA_1(); // A
Father::getConstA_2(); // A
Father::getConstA_3(); // A

1.6 小节

本类实例访问本类的一非静态属性

只可以访问到 Public 修饰的属性

本类实例访问本类的一静态属性

只可以访问到 Public 修饰的属性

本类实例访问本类的一非静态方法

只可以访问到 Public 修饰的属性

本类实例访问本类的一静态方法

只可以访问到 Public 修饰的属性

本类实例访问本类的一类常量

实例无法访问到类中的常量