什么是封装？
把客观的事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的类进行信息的隐藏。简单的说就是：封装使对象的设计者与对象的使用者分开，使用者只要知道对象可以做什么就可以了，不需要知道具体是怎么实现的。封装可以有助于提高类和系统的安全性。
什么是继承？
继承指的是建立一个新的派生类，从一个或多个先前定义的类中继承数据和函数，可以重新定义或加进新数据和函数，从而建立了类的层次或等级。
什么是多态？
多态性指的是： 同一操作作用与不同类的实例，将产生不同的执行结果，即不同类的对象收到相同的消息时，将得到不同的结果。
class eat
{
public function breakfast()
{
echo "吃早饭！";
}
}
class typist
{
public function type()
{
echo "打字!";
}
}
function printWorking($obj)
{
if ($obj instanceof eat) {
echo $obj->breakfast();
} elseif ($obj instanceof typist) {
echo $obj->type();
} else {
echo "error";
}
}
printWorking(new eat());
echo PHP_EOL;
printWorking(new typist());输出：
吃早饭！ 打字!
单一职责原则，开放封闭原则，里氏替换原则，依赖倒置原则，接口隔离原则
什么是单一职责原则？
简单的来说就是： 一个类只做一件事情，不要为类实现过多的功能点，避免相同的职责分散到不同的类中。如果一个类的职责过多可能引起变化的原因也就越多，使代码更加的耦合。如果杂交不清的职责将使得代码难以维护，牵一发而动全身。
例如：工厂模式，工厂模式之所以被称为工厂模式是因为它负责 “生产” 对象。
工厂模式的好处：多个地方new了一个对象，当此类名发生改变就不需要一个个去修改，只需要修改一处地方。
<?php
class MyObject
{
public function __construct()
{
echo "test code";
}
}
//工厂类
class MyFactory
{
public static function factory()
{
return new MyObject();
}
}
$instance = MyFactory::factory();//test code什么是开放封闭原则？
开放封闭原则： 一个类是可扩展的，而不可修改的。也就是说，对扩展开放，对修改封闭。
1.对扩展开放，意味着 有新的需求或变化时，可以对现有的代码进行扩展，以适应新的情况。
2.对修改封闭，在对模块功能进行扩展时，不应该影响已有的程序模块。
实现开放封闭的原则的重点：抽象编程，而不是具体编程，因为抽象相对稳定，让类依赖与固定的抽象类和接口，所以修改就是封闭的。而面向对象的继承和多态机制，又可以继承抽象类或者实现接口，听过重写其方法来改变固有的行为，实现方法新的拓展，所以就是开放。
例如：装饰器模式（Decorator），可以动态地添加修改类的功能。一个类提供了一项功能，如果要在修改并添加额外的功能，传统的编程模式，需要写一个子类去继承它，并重新实现类的方法，使用装饰器模式，仅需在运行时添加一个装饰器对象即可实现，可以实现最大的灵活性。
<?php
/**
* 输出一个字符串
* 装饰器动态添加功能
* Class EchoText
*/
class EchoText
{
protected $decorator = [];
public function Index()
{
//调用装饰器前置操作
$this->beforeEcho();
echo "你好，我是装饰器。";
//调用装饰器后置操作
$this->afterEcho();
}
//增加装饰器
public function addDecorator(Decorator $decorator)
{
$this->decorator[] = $decorator;
}
//执行装饰器前置操作 先进先出原则
protected function beforeEcho()
{
foreach ($this->decorator as $decorator)
$decorator->before();
}
//执行装饰器后置操作 先进后出原则
protected function afterEcho()
{
$tmp = array_reverse($this->decorator);
foreach ($tmp as $decorator)
$decorator->after();
}
}
/**
* 装饰器接口
* Class Decorator
*/
interface Decorator
{
public function before();
public function after();
}
/**
* 颜色装饰器实现
* Class ColorDecorator
*/
class ColorDecorator implements Decorator
{
protected $color;
public function __construct($color)
{
$this->color = $color;
}
public function before()
{
echo "<dis style='color: {$this->color}'>";
}
public function after()
{
echo "</div>";
}
}
/**
* 字体大小装饰器实现
* Class SizeDecorator
*/
class SizeDecorator implements Decorator
{
protected $size;
public function __construct($size)
{
$this->size = $size;
}
public function before()
{
echo "<dis style='font-size: {$this->size}px'>**";
}
public function after()
{
echo "</div>";
}
}
//实例化输出类
$echo = new EchoText();
//增加装饰器
$echo->addDecorator(new ColorDecorator('red'));
//增加装饰器
$echo->addDecorator(new SizeDecorator('22'));
//输出
$echo->Index();什么是里氏替换原则？
由于面向对象编程技术中的继承在具体编程中过于简单，在许多系统的设计和编程实现中，我们并没有认真地、理性地思考应用系统中各个类之间的继承好关系是否合适，派生类是否能正确地对基类中的某些方法进行重写的问题。因此经常出现滥用继承或者错误的继承现象，给系统后期的维护带来了不少麻烦。
核心思想：子类必须能够替换其父类。这一思想体现为对继承机制的约束规范，只有子类能够替换父类时才能保证系统在运行期内识别子类，这是保证继承复用的基础。
<?php
//例子1
class Bird{
protect function fly(){
}
}
//翠鸟
class KingFisher extends Bird{
}
//鸵鸟
class Ostrich extends Bird{
//鸵鸟不会飞啊
}
//例子2
class A{
protect function add($a, $b){
return $a + $b;
}
}
//重载
class B extends A{
protected function add($a, $b){
return $a + $b + 100;
}
}里氏替换原则是对类继承的一种约束。对里氏替换原则有两种理解：
1.不能随便去继承不合适的，有多余方法或者属性的类（例子1）。
2.子类可以扩展父类的功能，但不能改变父类原有的功能（例子2）。
里氏替换原则包含一下几个隐藏含义：
1.子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法。
2.子类中可以增加自己特有的方法。
3.当子类的方法重载父类的方法时，方法的前置条件（即方法的形参）要比父类方法的输入参数更宽松。
4.当子类的方法实现父类的抽象方法时，方法的后置条件（即方法的返回值）要比父类更严格。
什么是依赖倒置原则？
简单的来说就是：一个类，不应该强制依赖另一个类，每个类对于另外一个类都是可替换的。
具体概念：
1.上层模块不应该依赖于下层模块，它们共同依赖于一个抽象（父类不能依赖子类，它们都要依赖抽象类）。
2.抽象不能依赖于具体，具体应该依赖于抽象。
为什么要依赖接口？因为接口体现对问题的抽象，同时由于抽象一般是相对稳定的或者是相对变化不频繁的，而具体是易变的。因此，依赖抽象是实现代码扩展和运行期内绑定（多态）的基础：只要实现了该抽象类的子类，都可以被类的使用者使用。
<?php
interface employee
{
public function working();
}
class teacher implements employee//具体应该依赖与抽象
{
public function working(){
echo 'teaching...';
}
}
class coder implements employee
{
public function working(){
echo 'coding...';
}
}
class workA//例子1
{
public function work(){
$teacher = new teacher;
$teacher->working();
}
}
class workB//例子2
{
private $e;
public function set(employee $e){
$this->e = $e;
}
public function work(){
$this->e->working();
}
}
$worka = new workA;//workA 依赖于 teacher 类 不符合依赖倒置原则
$worka->work();
$workb = new workB;//workB 不依赖与某个类 既可以注入 teacher 也可以 注入 coder
$workb->set(new teacher());
$workb->work();在workA（例子1）中，work方法依赖于teacher实现；在workB（例子2）中，work转而依赖抽象，这样可以把需要的对象通过参数传入。上述代码通过接口，实现了一定程度的解耦，但仍然是有限的。不仅是使用接口，使用工厂等也能实现一定程度的解耦和依赖倒置。
在workB中，teacher实例通过set方法传入，从而实现了工厂模式。由于这样的实现仍然是硬编码的，为了实现代码的进一步扩展，把这个依赖关系写在配置文件里，指明workB需要一个teacher对象，专门由一个程序配置是否正确（如所依赖的类文件是否存在）以及加载配置中所依赖的实现，这个检测程序，就称为IOC容器（这里不清楚IOC的小伙伴可以自行谷歌）。
什么是接口隔离原则？
其核心思想是：使用多个小的专门的接口，而不要使用一个大的总接口（只需要关心接口，不需要关心实现）。
接口隔离原则体现在：
1.接口应该是内聚的，应该避免 “胖” 接口。
2.不要强迫依赖不用的方法，这是一种接口污染。
3.表明客户端不应该被强迫实现一些不会使用的接口，应该把胖接口分组，用多个接口代替它，每个接口服务于一个子模块。简单地说，就是使用多个专门的接口比使用单个接口要好很多。
隔离的手段主要有以下两种：
1、委托分离，通过增加一个新的类型来委托客户的请求，隔离客户和接口的直接依赖，但是会增加系统的开销（设计模式中，如：代理模式，策略模式中都用到了委托的概念，好奇的小伙伴可以自行谷歌，这里就不贴代码了）。
2、多重继承分离，通过接口多继承来实现客户的需求，这种方式是较好的。
胖接口的实例说明
<?php
interface Animal{
public function walk();
public function speak();
}
//实现狗的一个接口
class Dog implements Animal{
public function walk(){
echo "dogs can walk";
}
public function speak(){
echo "dogs can speak";
}
}
//ok，现在我们想创建一个鱼类，它会游泳，怎么办呢？
//我们必须要修改接口，还会影响到dog类的实现，而fish也需要实现walk和speak方法，如下代码所示：
interface Animal{
public function walk();
public function speak();
public function swim();
}
//修改后的Gog类
class Dog implements Animal{
public function walk(){
echo "dogs can walk";
}
public function speak(){
echo "dogs can speak";
}
public function swim(){
}
}
//鱼类
class Fish implements Animal{
public function walk(){
}
public function speak(){
}
public function swim(){
echo "fish can swim";
}
}这时Animal接口类就呈现出了”胖“接口的特征了。所谓胖接口其实就是接口中定义了不是所有实现类都需要的方法，就像Animal接口类，有些动物是不会游泳的，有些动物是不会行走的，还有些动物是不会飞的。如果将这些方法都写在一个Animal接口类中，那么后期的扩展和维护简直就是一场灾难。
那么，怎么解决以上问题呢？
很简单，接口细化即可，将Animal接口类拆分成三个接口类，然后用多继承分离接口就ok了。
<?php
interface animalCanSpeak{
public function speak();
}
interface AnimalCanSwim{
public function swim();
}
interface animalCanSpeak{
public function speak();
}
//定义好这几个接口类之后，dog和fish的实现就容易多了
//狗类
class Dog implements animalCanSpeak,animalCanWalk{
public function walk(){
echo "dogs can walk";
}
public function speak(){
echo "dogs can speak";
}
}
//鱼类
class Fish implements AnimalCanSwim{
public function swim(){
echo "fish can swim";
}
}接口隔离原则(Interface Segregation Principle, ISP)的概念：使用多个专门的接口，而不使用单一的总接口，即客户端不应该依赖那些它不需要的接口。
在使用接口隔离原则时，我们需要注意控制接口的粒度，接口不能太小，如果太小会导致系统中接口泛滥，不利于维护；接口也不能太大，太大的接口将违背接口隔离原则，灵活性较差，使用起来很不方便。一般而言，接口中仅包含为某一类用户定制的方法即可，不应该强迫客户依赖于那些它们不用的方法。
实践出真理
Atas ialah kandungan terperinci 面向对象的三大特性和五大原则是什么. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
Apakah fail .Xauthority?
Penyelesaian untuk membahagikan jadual perkataan kepada dua muka surat
Garis miring jadual Excel dibahagikan kepada dua
Apakah pemacu optik
Penyelesaian kepada pengecualian pengecualian perisian yang tidak diketahui dalam aplikasi komputer
Apakah platform Fengxiangjia?
Apakah enjin carian direktori yang ada?
Apakah perisian Penguin?
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
