访问控制（可见性）
PHP 中，对类中的成员（属性和方法）的访问控制，是通过以下三个访问修饰符来实现的。
public（公有的）
protected（受保护的）
private（私有的）
public、protected 和 private 可以控制类成员的可见性（visibility）。
被定义为 public 的类成员，可以在任何地方被访问（任何地方可见）。
被定义为 protected 的类成员，可以在其自身、子类和父类的内部访问。
被定义为 private 的类成员，只能在其定义的类内部访问。
<?php

class A
{
    public $public = 'Public';
    protected $protected = 'Protected';
    private $private = 'Private';
    const HASH = 'md5';
    const STATUS = ['success'=>0, 'fail'=>1];
    static $static = 'static';
    public static $s1 = [];

    public function __construct($alias)
    {
        $this->alias = $alias;   // 动态添加的属性，默认是 public。（不能动态添加一个静态属性）
    }

    function printHello()
    {
        // 在定义的类内部，可以访问自身的所有属性
        echo $this->public;
        echo $this->protected;
        echo $this->private;
        echo '<br>';
    }

    /**
     *  在父类中访问子类的成员，子类的 public、protected 的成员在父类中可见
     */
    public function accessChildClass() {
        $child = new static('b2');   // static 后期静态绑定
        echo $child->protected;echo '--';
        echo $child->alias;
        echo '<br>';
    }
}

class B extends A
{
    protected $protected = 'Protected2';

    function printHello()
    {
        echo $this->public;
        echo $this->protected;
        echo $this->private;
        echo '<br>';
    }

    /**
     *  在子类中访问父类的成员，父类的 public、protected 的成员在子类中可见
     */
    public function accessParentClass() {
        $parent = new parent('a2');
        echo $parent->protected; echo '--';
        echo $parent->alias;
        echo '<br>';
    }
}

$obj = new A('a');
echo $obj->public; echo '<br>'; // 正常执行，public 的属性在任何地方可见
//echo $obj->protected; // 致命错误，因为 protected 的属性，只能在其自身、子类和父类中访问。致命错误会终止程序执行。
//echo $obj->private; // 致命错误
$obj->printHello(); // 正常执行，输出 Public、Protected 和 Private
echo $obj->alias; echo '<br>';  // 正常执行，动态添加的属性，默认是 public
echo A::HASH; echo '<br>';  // 正常执行，类常量在任何地方可见，是属于类的，而不是属于对象
echo B::HASH; echo '<br>';  // 正常执行，类常量可以被子类继承

$b = new B('b');
echo $b->public; echo '<br>';  // Public
echo $b->private; echo '<br>';  // Notice: Undefined property
//echo $b->protected;  // Fatal error: Uncaught Error: Cannot access protected property
$b->printHello();  // Public、Protected2、Notice: Undefined property: B::$private

$b->accessChildClass(); // Protected2--b2，可以在父类中访问子类的 protected 和 public 的属性
$b->accessParentClass(); // Protected--a2, 也可以在子类中访问父类的 protected 和 public 的属性

var_dump(B::STATUS); echo '<br>';   // array(2) { ["success"]=> int(0) ["fail"]=> int(1) }

echo A::$static; echo '<br>';   // static
echo B::$static; echo '<br>';   // static

var_dump(B::$s1); echo '<br>';   // array(0) { }
属性的可见性
类中的属性的可见性，除了遵循下面三条通用的规则：
public 的属性，可以在任何地方被访问（任何地方可见）。
protected 的属性，可以在其自身、子类和父类的内部访问。
private 的属性，只能在其定义的类内部访问。
还需注意以下几点：
动态添加的属性，默认是 public 。（不能动态添加一个静态属性）
static 关键字修饰的静态属性，默认是 public 。
非静态属性，必须指定访问修饰符 public、protected 和 private 中的任意一个。
非静态属性的访问方式
通过 $this 访问，如 $this->public;
通过具体的对象访问，如 (new A('a'))->public;
静态属性的访问方式
通过 self::、parent:: 和 static:: 访问，如：self::$static;
通过具体的类名访问，如：A::$static;
方法的可见性
类中的方法的可见性，除了遵循下面三条通用的规则：
public 的方法，可以在任何地方被访问（任何地方可见）。
protected 的方法，可以在其自身、子类和父类的内部访问。
private 的方法，只能在其定义的类内部访问。
还需注意以下几点：
方法如果没有明确指定可见性，默认是 public 。
也可用 static 关键字将方法修饰为静态方法。
可以看出，方法的可见性和属性的可见性的规则基本是一致的。
非静态方法的调用方式
通过 $this 访问，如 $this->foo();
通过具体的对象访问，如 (new B)->foo();
通过 self::、parent:: 和 static:: 访问，如 static::foo();
通过具体的类名访问，如 B::foo();
在 PHP 7 中，已经废弃（弃用）了静态调用非静态的方法，未来可能会移除该功能。
静态方法的调用方式
通过 self::、parent:: 和 static:: 访问，如 static::foo();
通过具体的类名访问，如 B::foo();
通过 $this 访问，如 $this->foo();
通过具体的对象访问，如 (new B)->foo();
类常量
类常量指的是在类内部的头部位置定义的常量。
如：
class A
{
    const HASH = 'md5';
    const STATUS = ['success'=>0, 'fail'=>1];
    
    public function foo() { }
}
可以把在类中始终保持不变的值定义为常量。
定义类常量只能使用 const 关键字。
常量的值必须是一个定值，不能是变量，类属性或其它操作（如函数调用）的结果。
在 PHP5.6 中，对 const 常量进行了增强，允许常量计算，允许使用包含数字、字符串字面值和常量的表达式结果来定义 const 常量。常量的值也可以是数组，但不能是变量。
关于类常量，还需注意以下几点：
类常量是属于类本身，而不是属于对象。
类常量的访问方式和静态属性一致。
类常量可以被继承。
类常量不能被访问修饰符 public、protected 和 private 修饰。
类常量不能被静态修饰符 static 修饰。
类常量区分大小写。
在 PHP 中，变量、常量区分大小写，函数和类名不区分大小。但魔术常量不区分大小写。
继承
在 PHP 中，类的继承会影响到类与类、对象与对象之间的关系。
关于类的继承，需要注意以下几点：
只有可见性为 public 和 protected 的属性和方法，才可以被子类继承。
可见性为 private（私有）的属性或方法，不能被继承。
类常量可以被继承。
被子类继承的属性，可以在子类中重写（覆盖）；否则，将沿用原有的值。
被子类继承的方法，也可在子类中重写（覆盖）；否则，将沿用原有的功能。
<?php

class Person
{
    public $name;
    protected $age=18;
    private $phone='';

    public function getName()
    {
        echo $this->name;
    }

    protected function getAge()
    {
        echo $this->age;
    }

    protected function getClass()
    {
        echo __CLASS__;
    }


    private function getPhone()
    {
        echo $this->phone;
    }
}

class Tom extends Person
{
    protected $age = 20;

    public function getName()
    {
        echo $this->name . '--' . __CLASS__; echo '<br>';
    }

    public function printInfo()
    {
        $this->getAge();    echo '--';
        parent::getAge();   echo '--';
        parent::getClass();
    }
}

$obj = new Tom();
$obj->getName();    // --Tom

$obj->printInfo();  // 20--20--Person

String是所有语言中最常用的一个类。我们知道在Java中，String是不可变的、final的。Java在运行时也保存了一个字符串池(String pool)，这使得String成为了一个特别的类。
 
主要是为了 “ 效率 ” 和 “ 安全性 ” 的缘故。 若 String 允许被继承, 由于它的高度被使用率, 可能会降低程序的性能，所以 String 被定义成 final。
 
 
 
一：String 和其他基本类型不同 , 他是个对象类型. 既然是对象类型 , 如果是在静态方法下是必须调用静态方法或值的 , 如果是非静态的方法 , 就必须要实例化.
 
 
 
main 函数是个 static 的. 所以String 要能像其他的基本类型一样直接被调用. 这也是为什么在 main 函数下使用 String 类型不会报告错误的原因..
 
 
 
一下就解释了两个心里的疑问..
 
 
 
以前一直觉得奇怪 ,为什么 String 是对象类型在 main 函数下却是不需要实例化的. 再次佩服 java 设计人员想得真周到.
 
 
 
二：当定义 String 类型的静态字段（也成类字段），可以用静态变量（非 final）代替常量（final）加快程序速度。 反之，对于原始数据类型，例如 int，也成立。
 
 
 
例如，你可能创建一个如下的 String 对象：
 
 
 
Privatestatic final Stringx="example";
 
对于这个静态常量（由 final 关键字标识），你使用常量的每个时候都会创建一个临时的 String 对象。 在字节代码中，编译器去掉 ”x”，代替它的是字符串 “example”, 以致每次引用 ”x” 时 VM 都会进行一次哈希表查询。
 
 
 
相比之下，度于静态变量 ( 非 final 关键字 )，字符串只创建一次。 仅当初始化 “x” 时， VM 才进行哈希表查询。
 
 
 
还有另一个解释 :
 
带有 final 修饰符的类是不可派生的。 在 java 核心 API 中，有许多应用 final 的例子，例如 java.lang.String。 为 String 类指定 final 防止了人们覆盖 length() 方法。
 
 
 
另外，如果指定一个类为 final，则该类所有的方法都是 final。 java 编译器会寻找机会内联（inline）所有的 final 方法（这和具体的编译器实现有关）。 此举能够使性能平均提高 50%。
 
 
 
示例：
 
 
 
publicclassTest{
 
publicstaticvoidmain(String[]args){
 
//
 
}
 
}
 
如果 String 不是 final 那么就可以继承
 
 
 
publicclassString2extendsString{
 
//..
 
//...
 
}
 
那我们的 main 也就可以写成
 
 
 
publicclassTest{
 
publicstaticvoidmain(String2[]args){//注意此处
 
//
 
}
 
}
 
英文参考：http://forums.sun.com/thread.jspa?threadID=636414
 
 
 
另外补充一点：
 
作用就是 final的类不能被继承，不能让别人继承有什么好处?
 
 
 
意义就在于，安全性，如此这般：
 
java 自出生那天起就是“为人民服务”，这也就是为什么java做不了病毒，也不一定非得是病毒，反正总之就是为了安全， 人家java的开发者目的就是不想让 java干这类危险的事儿，java并不是操作系统本地语言， 换句话说java必须借助操作系统本身的力量才能做事，JDK中提供的好多核心类比如 String，这类的类的内部好多方法的实现都不是java编程语言本身编写的， 好多方法都是调用的操作系统本地的API，这就是著名的“本地方法调用”，也只有这样才能做事，这种类是非常底层的， 和操作系统交流频繁的，那么如果这种类可以被继承的话，如果我们再把它的方法重写了，往操作系统内部写入一段具有恶意攻击性质的代码什么的， 这不就成了核心病毒了么？
 
 
 
上面所述是最重要的，另外一个方面，上面2位老兄说的也都很对， 就是不希望别人改，这个类就像一个工具一样，类的提供者给我们提供了， 就希望我们直接用就完了，不想让我们随便能改，其实说白了还是安全性， 如果随便能改了，那么java编写的程序肯定就很不稳定，你可以保证自己不乱改， 但是将来一个项目好多人来做，管不了别人，再说有时候万一疏忽了呢？他也不是估计的， 所以这个安全性是很重要的，java和C++相比，优点之一就包括这一点；
 
 
 
原因绝对不只有这么多，因为如果这些个核心的类都能被随便操作的话，那是很恐怖的，会出现好多好多未知的错误，莫名其妙的错误….
 
 
 
String类不可变性的好处：
 
 
 
只有当字符串是不可变的，字符串池才有可能实现。字符串池的实现可以在运行时节约很多heap空间，因为不同的字符串变量都指向池中的同一个字符串。但如果字符串是可变的，那么String interning将不能实现(译者注：String interning是指对不同的字符串仅仅只保存一个，即不会保存多个相同的字符串。)，因为这样的话，如果变量改变了它的值，那么其它指向这个值的变量的值也会一起改变。
 
 
 
如果字符串是可变的，那么会引起很严重的安全问题。譬如，数据库的用户名、密码都是以字符串的形式传入来获得数据库的连接，或者在socket编程中，主机名和端口都是以字符串的形式传入。因为字符串是不可变的，所以它的值是不可改变的，否则黑客们可以钻到空子，改变字符串指向的对象的值，造成安全漏洞。
 
 
 
因为字符串是不可变的，所以是多线程安全的，同一个字符串实例可以被多个线程共享。这样便不用因为线程安全问题而使用同步。字符串自己便是线程安全的。
 
 
 
类加载器要用到字符串，不可变性提供了安全性，以便正确的类被加载。譬如你想加载java.sql.Connection类，而这个值被改成了myhacked.Connection，那么会对你的数据库造成不可知的破坏。
 
 
 
因为字符串是不可变的，所以在它创建的时候hashcode就被缓存了，不需要重新计算。这就使得字符串很适合作为Map中的键，字符串的处理速度要快过其它的键对象。这就是HashMap中的键往往都使用字符串 

答案是不能的。
 
因为我们查看String源码就知道，String被关键字final修饰，所以不能被继承。
 
这里就要简单介绍一下final的基础。
 
1、修饰类当用final去修饰一个类的时候，表示这个类不能被继承。注意：a. 被final修饰的类，final类中的成员变量可以根据自己的实际需要设计为fianl。b. final类中的成员方法都会被隐式的指定为final方法。说明：在自己设计一个类的时候，要想好这个类将来是否会被继承，如果可以被继承，则该类不能使用fianl修饰，在这里呢，一般来说工具类我们往往都会设计成为一个fianl类。在JDK中，被设计为final类的有String、System等。
 2、修饰方法
 被final修饰的方法不能被重写。
 注意：
 a. 一个类的private方法会隐式的被指定为final方法。
 b. 如果父类中有final修饰的方法，那么子类不能去重写。
 3、修饰成员变量
 注意：
 a. 必须初始化值。
 b. 被fianl修饰的成员变量赋值，有两种方式：1、直接赋值 2、全部在构造方法中赋初值。
 c. 如果修饰的成员变量是基本类型，则表示这个变量的值不能改变。
 d. 如果修饰的成员变量是一个引用类型，则是说这个引用的地址的值不能修改，但是这个引用所指向的对象里面的内容还是可以改变的。
 
总之final就是像C语言中的const一样，代表一个常量，你在一开始初始化就要赋值，也不允许你改变它。
 
参考链接：http://baijiahao.baidu.com/s?id=1601084106055683243&wfr=spider&for=pc
 

C++中，并不是所有的成员函数都能被子类继承，有三类成员函数不能被子类继承，分别是：构造函数（包括拷贝构造）、析构函数、赋值运算符重载函数。
 
1. 构造函数 　　
 
构造方法用来初始化类的对象，与父类的其它成员不同，它不能被子类继承（子类可以继承父类所有的成员变量和成员方法，但不继承父类的构造方法）。因此，在创建子类对象时，为了初始化从父类继承来的数据成员，系统需要调用其父类的构造方法。 　　如果没有显式的构造函数，编译器会给一个默认的构造函数，并且该默认的构造函数仅仅在没有显式地声明构造函数情况下创建。 构造原则如下：
 
1. 如果子类没有定义构造方法，则调用父类的无参数的构造方法。
 
2. 如果子类定义了构造方法，不论是无参数还是带参数，在创建子类的对象的时候,首先执行父类无参数的构造方法，然后执行自己的构造方法。
 
3. 在创建子类对象时候，如果子类的构造函数没有显示调用父类的构造函数，则会调用父类的默认无参构造函数。
 
4. 在创建子类对象时候，如果子类的构造函数没有显示调用父类的构造函数且父类自己提供了无参构造函数，则会调用父类自己的无参构造函数。
 
5. 在创建子类对象时候，如果子类的构造函数没有显示调用父类的构造函数且父类只定义了自己的有参构造函数，则会出错（如果父类只有有参数的构造方法，则子类必须显示调用此带参构造方法）。
 
6. 如果子类调用父类带参数的构造方法，需要用初始化父类成员对象的方式 
 
构造函数不能为虚：
 
虚函数的作用是允许在派生类中重新定义与基类同名的函数，并且可以通过基类指针或引用来访问基类和派生类中的同名函数。
 
https://blog.csdn.net/LC98123456/article/details/81143102
 
要成为虚函数必须满足两点，一就是这个函数依赖于对象调用，因为虚函数就是依赖于对象调用，因为虚函数是存在于虚函数表中，有一个虚函数指针指向这个虚表，所以要调用虚函数，必须通过虚函数指针，而虚函数指针是存在于对象中的。二就是这个函数必须可以取地址，因为我们的虚函数表中存放的是虚函数函数入口地址，如果函数不能寻址，就不能成为虚函数。构造函数内联函数不可作为虚函数
 
2. 析构函数 　　
 
析构函数也不会被子类继承，只是在子类的析构函数中会调用父类的析构函数。
 
如果没有将基类的析构函数定义为虚函数
当基类指针指向子类对象时，如果基类的析构函数不是virtual，那么子类的析构函数将不会被调用，子类的资源没有正确是释放，因此造成内存泄露
3. 赋值运算符重载函数 　　
 
赋值运算符重载函数也不会被子类继承，只是在子类的赋值运算符重载函数中会调用父类的赋值运算符重载函数。