旗下导航:搜·么
当前位置:网站首页 > PHP问题 > 正文

面向对象的三大特征和五大准绳是什么【php题目】

作者:搜搜PHP网发布时间:2019-11-26分类:PHP问题浏览:80


导读:面向对象的三大特性封装,继续,多态什么是封装?把客观的事物封装成笼统的类,而且类可以把本身的数据和要领只让可托的类或许对象操纵,对不可托的类举行信息的隐蔽。简朴...

面向对象的三大特性

封装,继续,多态

什么是封装?

把客观的事物封装成笼统的类,而且类可以把本身的数据和要领只让可托的类或许对象操纵,对不可托的类举行信息的隐蔽。简朴的说就是:封装使对象的设想者与对象的运用者离开,运用者只需晓得对象可以做什么就可以了,不需要晓得细致是怎样完成的。封装可以有助于进步类和体系的安全性。

什么是继续?

继续指的是竖立一个新的派生类,从一个或多个先前定义的类中继续数据和函数,可以从新定义或加进新数据和函数,从而竖立了类的条理或品级。

什么是多态?

多态性指的是: 统一操纵作用与差别类的实例,将发作差别的实行效果,即差别类的对象收到雷同的音讯时,将获得差别的效果。

代码示例

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)的观点:运用多个特地的接口,而不运用单一的总接口,即客户端不该当依靠那些它不需要的接口。

在运用接口断绝准绳时,我们需要注重掌握接口的粒度,接口不能太小,假如太小会致使体系中接口众多,不利于保护;接口也不能太大,太大的接口将违犯接口断绝准绳,灵活性较差,运用起来很不轻易。平常而言,接口中仅包括为某一类用户定制的要领即可,不该当强制客户依靠于那些它们不必的要领。

结语

实践出真谛

以上就是面向对象的三大特性和五大准绳是什么的细致内容,更多请关注ki4网别的相干文章!

标签:面向对象三大特性五大原则