六大原则与设计模式

【设计模式】多维度轻松记住设计模式的六大原则 设计模式的六大原则是构建优秀软件架构的基石,本文通过六种趣味记忆法帮助开发者轻松掌握这些核心原则。文章提供场景联想、图像记忆、谐音口诀等创意方法,让抽象原则变得生动易记。掌握这些原则能显著提升代码质量和可维护性,其中OCP是设计模式的核心目标,其他原则都是实现它的具体手段。 阅读详情

1. 六大原则

1.1 单一原则(SRP)

应该有且仅有一个原因引起类的变更

1. 复杂性降低,可读性高,可维护性提高

2. 变更引起的风险降低,变更是必不可少的,如果接口的单一职责做得好,一个接口修改只对相应的实现类有影响,对其他的接口无影响,这对系统的扩展性、维护性都有非常大的帮助。

class a{
    public function info(){
        echo "第一条消息";
    }
}
class b{
    public function text(){
        echo "第二条消息";
    }
}
class c {
    public function run(){
        $a = new a();
        $a->info();
        $b = new b();
        $b->text();
    }
}
$c = new c();
$c->run();
1.2 开闭原则

类应该对扩展开放,对修改关闭

interface A{
    public function boot();
}

class B implements A{
    public function boot(){
      return rand(1,100);
    }
}

class cli{
    public function run(){
        $b= new B();
        return $b->boot();
    }
}
$cli = new cli();
echo $cli->run();
1.3 里氏替换原则

子类必须能够替换掉它们的基类

class A{
    public function a(){
        return "电子产品";
    }
}
class B extends A{
    public function a()
    {
        return "手机";
    }
}
class client
{
    public function run()
    {
        $b = new B();
        echo $b->a();

    }
}
$client = new client();
$client->run();
1.4 依赖倒置原则

高层模块不应该依赖于低层模块,它们都应该依赖于抽象。

interface A{
    public function str();
}

class B implements A{
    public function str()
    {
        return rand(1,100);
    }
}
class C implements A{
    public function str()
    {
        return "123";
    }
}
1.5 接口隔离原则 (ISP)   

类不应该依赖于它不需要的接口

interface A{
    public function a();
    public function b();
}
class B implements A{
    public function a()
    {
        return "a";
    }
    public function b()
    {
        return "b";
    }
}

1.6 迪米特法则

优先使用对象组合而不是类继承

class a{
    protected  $user;
    public  function __construct(\think\App $app)
    {
        $this->user=$app;
    }

    public function index($id){
        return $this->user->index($id);
    }
}

这些原则有助于写出高内聚、低耦合的代码,使得代码更易于维护和扩展。

2. 设计模式

2.1 结构型模式
2.1.1 装饰器模式

装饰器模式用于动态地将新的行为添加到对象上,对于需要扩展功能的类来说是一种更加灵活的设计方案。在PHP中,可以使用装饰器模式来为已有的对象添加新的行为,不需要修改已有类的代码。

装饰器的优点:

1. 不改变代码的情况下对原代码的功能职责进行扩展,遵守了开闭原则

2. 每个类都有属于自己的功能职责

interface MobileCase
{
    public function boot();
}

class Mobile implements MobileCase
{
    public function boot()
    {
        echo "无色无图案手机壳".PHP_EOL;
    }
}

abstract class MobileDecorator implements MobileCase
{
    protected $mobileCase;

    public function __construct(MobileCase $mobileCase)
    {
        $this->mobileCase = $mobileCase;
    }

    public function boot()
    {
        $this->mobileCase->boot();
    }
}

class HedMobileCase extends MobileDecorator
{
    private $name = "红色手机壳";

    private function add()
    {
        echo $this->name.PHP_EOL;
    }

    public function boot()
    {
        $this->mobileCase->boot();
        $this->add();
    }
}

class GreenMobileCase extends MobileDecorator
{
    private $name = "黄色手机壳";

    private function add()
    {
        echo $this->name.PHP_EOL;
    }

    public function boot()
    {
        $this->mobileCase->boot();
        $this->add();
    }
}

class client
{
    public function run()
    {
        $MobileCase = new Mobile();
        $HedMobileCase = new HedMobileCase($MobileCase);
        $HedMobileCase->boot();
    }
}

$client = new client();
$client->run();
2.1.2 facade门面模式

又称为外观模式,为子系统中的一组接口提供一个统一的高层接口, 使得子系统更容易使用

门面模式的组成:

1. 外观角色 :模式的核心,被客户 Client 调用,知道各个子系统的概念。

2. 子系统角色 :实现子系统的功能。

3. 客户角色 :调用 Facade 角色获取相应的功能。

门面模式的优缺点:

1. 降低系统的复杂程度 2. 低耦合 3. 使用简单 4. 可能违背开闭原则

class Connection
{
    private function conn()
    {
        try {
            $connection = new PDO('mysql:host=127.0.0.1;dbname=starsky','root','root');
            return $connection;
        }catch (PDOException $exception){
            echo $exception->getMessage();
        }
    }

    public function run()
    {
        return $this->conn();
    }
}
class DBQuery
{
    public function query(Connection $connection,$sql)
    {
        try {
            $pdo = $connection->run();
            $restful = $pdo->query($sql)->fetchAll();
            return $restful;
        }catch (PDOException $exception){
            echo $exception->getMessage();
        }
    }
}
class facade
{
    private $query;

    private $conn;

    public function __construct()
    {
        $this->query = new DBQuery();
        $this->conn = new Connection();
    }

    public function select($sql)
    {
        return $this->query->query($this->conn,$sql);
    }
}
class DB
{
    private static $query;

    public static function select($sql)
    {
        static::$query = new facade();
        return self::$query->select($sql);
    }
}
var_dump(DB::select('select * from `user`'));
2.1.3 注册树模式

通过将对象实例注册到一棵全局的对象树上,需要的时候从对 象树上采摘的模式设计方法

1. Laravel框架的服务容器          2. Thinkphp框架


class Container
{
   private $bindings = [];

   public function bind($abstract, $concrete = null, $shared = false)
   {
       $this->bindings[$abstract]['concrete'] = $concrete;
       $this->bindings[$abstract]['shared'] = $shared;
   }

   public function make($abstract,$parameters = [])
   {
       $object = $this->bindings[$abstract]['concrete'];

       if ($object instanceof \Closure){
           return $object();
       }

       if (!is_object($object)){
           $object = new $object(...$parameters);
       }

       return  $object;
   }

   public function delete($abstract)
   {
       unset($this->bindings[$abstract]);
   }
}
class A
{
   public function run()
   {
       echo "这里是A类的run方法";
   }
}

$container = new Container();
$container->bind('a',new A());
$container->make('a')->run();

class Container
{
   //用于存储实例化的对象或者类的命名空间
   private $bindings = [];

   //注册对象到$bindings数组里面,进行存储
   public function bind($abstract, $concrete = null)
   {
       $this->bindings[$abstract] = $concrete;
   }
}
class A{

}
$container = new Container();
$container->bind('A',new A());
interface I
{
    public function boot();
}
/**
 * Class A php项目生成的数据 => 给java语言接口
 */
class A implements I
{
    public function boot()
    {
        $data = ["id" =>1,"name" => "starsky"];
        return json_encode($data);
    }
}

/**
 * Class B java生成的数据 =>php语言接口
 */
class B implements I
{
    public function boot()
    {
        $data = ["id" =>1,"name" => "starsky"];
        return serialize($data);
    }
}

interface I_Apadtor
{
    public function boot(I $i);
}

class Apadtor implements I_Apadtor
{
    public function boot(I $i)
    {
        if (!is_null($string = json_decode($i->boot()))){
            return serialize($string);
        }else{
            $string = unserialize($i->boot());
            return json_encode($string);
        }
    }
}
$Apadtor = new Apadtor();
//java端调用php端数据
var_dump("java调用php的数据:".$Apadtor->boot(new A()));
//php端调用java端数据
var_dump("php调用java的数据:".$Apadtor->boot(new B()));

2.1.4 适配器模式

将一个类的接口,转换成客户期望的另一个类的接口。适配器让原 本接口不兼容的类可以合作无间。

interface I
{
   public function boot();
}

class A implements I
{
   public function boot()
   {
       $data = ["name" => "starsky","age" => 100,"sex" => 1];
       return serialize($data);
   }
}

class B implements I
{
   public function boot()
   {
       $data = ["name" => "starsky","age" => 100,"sex" => 1];
       return json_encode($data);
   }
}

interface I_Adaptor
{
   public function boot(I $i);
}

class Adaptor implements I_Adaptor
{
   public function boot(I $in)
   {
       if (!is_null($string = json_decode($in->boot()))){
           return serialize($string);
       }else{
           $string = unserialize($in->boot());
           return  json_encode($string);
       }
   }
}

$Adaptor = new Adaptor();
var_dump(json_decode($Adaptor->boot((new A()))));
var_dump(unserialize($Adaptor->boot((new B ()))));
2.1.5 Pipeline模式

应用场景: 1.订单生成 2.Laravel中中间件的执行

class A
{
    public static function handle($request)
    {
        echo "这里A类的Boot方法".PHP_EOL;
    }
}
class B
{
    public static function handle($request)
    {
        echo "这里是B类的Boot方法".PHP_EOL;
    }
}
class C
{
    public static function handle($request)
    {
        echo "这里是C类的Index方法".PHP_EOL;
    }
}
class D
{
    public function index()
    {
        echo "这里是D类的index方法";
    }
}
interface PipelineInterface
{
    public function pipe($middleware);
    public function then();
}
class Pipeline implements PipelineInterface
{
    protected $Middleware = [];

    protected $request;

    public function __construct($object,$method,$argv = [])
    {
        $this->request['object'] = $object;
        $this->request['method'] = $method;
        $this->request['argv'] = $argv;
    }

    public function pipe($middleware)
    {
        $this->Middleware = $middleware;
        return $this;
    }

    public function then()
    {
        foreach ($this->Middleware as $value){
            call_user_func([$value,'handle'],$this->request);
        }
        return $this;
    }

    public function send()
    {
        $method = $this->request['method'];
        return $this->request['object']->$method(...$this->request['argv']);
    }
}
class Kernel
{
    protected $Middleware = [];

    public function handle(Pipeline $pipeline)
    {
        return $pipeline->pipe($this->Middleware)
            ->then()
            ->send();
    }
}
class Http extends Kernel
{
    protected $Middleware=[
        A::class,
        B::class,
        C::class
    ];
}
$httpKernel = (new Http())->handle(new Pipeline(new D(),'index'));

2.1.6 代理模式

给某一个对象提供一个代理,并由代理对象控制对原对象的引用

interface I
{
    public function boot();

    public function handle();
}

class A implements I
{
    public function boot()
    {
        echo "A类的boot方法".PHP_EOL;
    }

    public function handle()
    {
        echo "A类的handle方法".PHP_EOL;
    }
}

class Proxy implements I
{
    protected $A;

    public function __construct(I $i)
    {
        $this->A = $i;
    }

    public function boot()
    {
        $this->A->boot();
    }

    public function handle()
    {
        $this->A->handle();
    }
}

$Proxy = new Proxy(new A());
$Proxy->boot();
$Proxy->handle();
2.2 创建型模式
2.2.1 简单工厂模式

简单工厂的作用是实例化对象,而不需要客户了解这个对象属于哪个具体的子类。

//mysql报错日志
class MysqlLog
{
}
//Redis报错日志
class RedisLog
{
}
//用户操作错误日志
class UserLog
{
}
//代码错诶日志
class ErrorLog
{
}

class Product
{
    protected $Log;

    public function __construct(array $modules)
    {
        $factory = new LogFactory();
        foreach ($modules as $module){
            $this->Log[$module] = $factory->make($module);
        }
    }

    public function getLog()
    {
        return $this->Log;
    }
}

class LogFactory
{
    public function make($abstract)
    {
        switch ($abstract){
            case 'mysql':
                return new MysqlLog();
            case 'redis':
                return new RedisLog();
            case 'user':
                return new UserLog();
            case 'error':
                return new ErrorLog();
        }
    }
}

$Product = new Product(array(
    'mysql',
    'redis',
    'user',
    'error'
));
var_dump($Product->getLog());
2.2.2 Factory工厂模式

简单工厂模式的延伸,是在简单工厂的优点上去解决它的缺陷 

方法工厂模式的优点: 1.拥有良好的封装性,代码结构清晰 2. 拥有良好的扩展性 3. 屏蔽产品类

使用场景: 1. 日志记录 2. 多接口支付 3. 数据库连接封装

interface LogInterface
{
    public function log();
}
//mysql报错日志
class MysqlLog implements LogInterface
{
    public function log()
    {
        // TODO: Implement log() method.
    }
}
//Redis报错日志
class RedisLog implements LogInterface
{
    public function log()
    {
        // TODO: Implement log() method.
    }
}
//用户操作错误日志
class UserLog implements LogInterface
{
    public function log()
    {
        // TODO: Implement log() method.
    }
}
//代码错诶日志
class ErrorLog implements LogInterface
{
    public function log()
    {
        // TODO: Implement log() method.
    }
}

class Product
{
    protected $Log;

    public function __construct()
    {
        $this->Log = array(
            (new MysqlLogFactory())->make(),
            (new RedisLogFactory())->make(),
            (new UserLogFactory())->make(),
            (new ErrorLogFactory())->make()
        );
    }

    public function getLog()
    {
        return $this->Log;
    }
}

interface LogFactory
{
    public function make();
}

class MysqlLogFactory implements LogFactory
{
    public function make()
    {
        return new MysqlLog();
    }
}
class RedisLogFactory implements LogFactory
{
    public function make()
    {
        return new RedisLog();
    }
}
class UserLogFactory implements LogFactory
{
    public function make()
    {
        return new UserLog();
    }
}

class ErrorLogFactory implements LogFactory
{
    public function make()
    {
        return new ErrorLog();
    }
}
$product = new Product();
var_dump($product->getLog());
2.2.3 抽象工厂模式

给客户端提供一个接口,可以创建多个产品族中的产品对象 

抽象工厂模式的优缺点: 1. 分离了具体的实现类 2. 增加替换工厂类目变的方便 3. 有利于统一同一类型的类目

interface PayInterface
{
    public function pay();
}

class AliPay implements PayInterface
{
    public function pay()
    {
        return "支付宝支付";
    }
}

class TenPay implements PayInterface
{
    public function pay()
    {
        return "微信支付";
    }
}

interface LogInterface
{
    public function log();
}

class MysqlLog implements LogInterface
{
    public function log()
    {
        return "记录mysql日志";
    }
}

class RedisLog implements LogInterface
{
    public function log()
    {
        return "记录Redis日志";
    }
}

interface PayFactoryInterface
{
    public function AliPayMake();

    public function TenPayMake();
}

interface LogFactoryInterface
{
    public function MysqlLogMake();

    public function RedisLogMake();
}

class PayFactory implements PayFactoryInterface
{
    public function AliPayMake()
    {
        return new AliPay();
    }

    public function TenPayMake()
    {
        return new TenPay();
    }
}

class LogFactory implements LogFactoryInterface
{
    public function MysqlLogMake()
    {
        return new MysqlLog();
    }

    public function RedisLogMake()
    {
        return new RedisLog();
    }
}

class Order
{
    protected $log;

    protected $pay;

    public function __construct()
    {
        $LogFactory = new LogFactory();
        $PayFactory = new PayFactory();
        $this->log = array(
            'mysql' => $LogFactory->MysqlLogMake(),
            'redis' => $LogFactory->RedisLogMake()
        );
        $this->pay = array(
            'Ali' => $PayFactory->AliPayMake(),
            'Ten' => $PayFactory->TenPayMake()
        );
    }

    public function getLog()
    {
        return $this->log;
    }

    public function getPay()
    {
        return $this->pay;
    }
}

$order = new Order();
var_dump($order->getLog());
var_dump($order->getPay());
2.2.4 Single单例模式

保证一个类只有一个实例,并提供一个访问它的全局访问点

使用场景: 1. 数据库连接 2. 日志操作类 3. 请求管理类 4. 配置管理类

class Request
{
   private static $request;
   protected $method;
   protected $uriPath;
   private function __construct(){}
   private function __clone(){}
   public static function getRequest()
   {
       if (self::$request == null){
           self::$request = new Request();
       }
       self::$request->method = $_SERVER['REQUEST_METHOD'];
       self::$request->uriPath= $_SERVER['REQUEST_URI'];
       return self::$request;
   }
   public function getMethod()
   {
       return $this->method;
   }
   public function getUriPath()
   {
       return $this->uriPath;
   }
   public function isMethod($method):bool
   {
       return $this->method === strtoupper($method);
   }
}
$request = Request::getRequest();
var_dump($request->isMethod('get'));
2.3 行为型模式
2.3.1 策略模式

定义一系列的算法,把它们一个个封装起来,并且使它们可以相互替换

策略模式使用的业务场景: 1. 短语发送 2. 多支付接口 3. 日志记录  

interface PayInterface
{
    public function pay();
}
class AliPay implements PayInterface
{
    public function pay()
    {
        echo "支付宝支付";
    }
}
class TenPay implements PayInterface
{
    public function pay()
    {
        echo "微信支付";
    }
}
class Pay
{
    protected $pay;
    public function __construct(PayInterface $pay)
    {
        $this->pay = $pay;
    }
    public function getPay()
    {
        return $this->pay;
    }
}
$pay = new Pay(new AliPay());
$pay->getPay()->pay();
2.3.2 Observe观察者模式

多个对象间存在一对多的依赖关系,当一个对象的状态 发生改变时,所有依赖于它的对象都得到通知并被自动更新

观察者模式的使用场景: 1. 订单支付场景 2. 发布订阅类型的功能

观察者模式的优点: 1. 观察者与被观察者依赖于抽象 2. 观察者符合开闭原则,只要符合接口,就能够进行扩展

观察者模式的缺点: 1. 依赖于接口的关系,具备一定的局限性 2. 过多的观察者,代码运行消耗可能会很大

interface OrderPayInterface
{
    public function PayEvent($OrderId = null);
}

class OrderPay implements OrderPayInterface
{
    public function PayEvent($OrderId = null)
    {
        echo "订单ID为:{$OrderId}的订单状态为已支付".PHP_EOL;
    }
}
abstract class OrderEventAbstract
{
    private $Observer;

    public function register(OrderPayInterface $pay)
    {
        $this->Observer = $pay;
    }

    public function notify($OrderId)
    {
        $this->Observer->PayEvent($OrderId);
    }
}
class Order extends OrderEventAbstract
{
    public function pay($OrderId)
    {
        echo "支付成功".PHP_EOL;
        $this->notify($OrderId);
    }
}
$order = new Order();
$order->register(new OrderPay());
$order->pay(1);
2.3.3 命令链模式

以松散耦合主题为基础,发送消息、命令和请求,或通过一组处理 程序发送任意内容

命令链模式的应用场景: 1. 登录注册不同角色的业务操作 2. 直播间不同等级会员业务 3. 订单支付状态

interface CommandInterface
{
    public function runCommand($name,$argv);
}
class CreateControllerCommand implements CommandInterface
{
    public function runCommand($name, $argv)
    {
        echo "创建控制器".PHP_EOL;
    }
}
class CreateModelCommand implements CommandInterface
{
    public function runCommand($name, $argv)
    {
        echo "创建模型".PHP_EOL;
    }
}
class Command
{
    private $command = [];
    public function register(array $command)
    {
        $this->command = $command;
    }
    public function run($name,$argv)
    {
        foreach ($this->command as $key=>$value){
            if ($name == $key){
                return $value->runCommand($name,$argv);
            }
        }
    }
}
$command = new Command();
$command->register(array(
    'controller' => new CreateControllerCommand(),
    'model' => new CreateModelCommand()
));
$command->run('model',1);
interface RoleLoginInterface
{
    public function handle($name);
}

class bronze implements RoleLoginInterface
{
    public function handle($name)
    {
        echo "欢迎{$name}进入直播间".PHP_EOL;
    }
}

class silver implements RoleLoginInterface
{
    public function handle($name)
    {
        echo "欢迎白银会员{$name}进入直播间".PHP_EOL;
    }
}

class gold implements RoleLoginInterface
{
    public function handle($name)
    {
        echo "欢迎黄金大神{$name}进入直播间,此时有掌声与音乐".PHP_EOL;
    }
}

class Role
{
    private $role = [];
    public function register(array $role)
    {
        $this->role = $role;
    }
    public function LoginEvent($name,$role)
    {
        foreach ($this->role as $key => $value){
            if ($role == $key){
                return $value->handle($name);
            }
        }
    }
}
$role = new Role();
$role->register(array(
    'bronze' => new bronze(),
    'silver' => new silver(),
    'gold'   => new gold()
));
$role->LoginEvent('harry','bronze');
$role->LoginEvent('xx','gold');
$role->LoginEvent('lori','silver');
2.3.4 迭代器模式

提供一种方法顺序访问一个聚合对象中各个元素,而又不暴露该 对象的内部显示

迭代器模式的角色: 1. 迭代器:迭代器定义访问和遍历元素的接口 2. 具体迭代器: 实现迭代器接口,对该聚合遍历时跟踪当前位置 3. 聚合: 聚合实现创建相应迭代器的接口,这个操作是返回具体迭代器的实例

迭代器的优点: 1.多种遍历方式 2.简化聚合类 3.为不同的集合提供统一的接口

迭代器的缺点: 迭代器模式将存储数据和遍历数据的职责分离增加新的集合对象时需要增加 对应的迭代器类,类的个数成对增加,在一定程度上增加系统复杂度

使用场景: 1.访问一个聚合对象的内容而无需暴露它的内部表示 2.支持对聚合对象的多种遍历 3.为遍历不同的聚合结构提供一个统一的接口

class CycleIterator implements Iterator
{
    private $array = [];
    private $currentIndex = 0;
    public function __construct($array)
    {
        $this->array = $array;
    }
    public function current()
    {
        return $this->array[$this->currentIndex];
    }
    public function setCurrentIndex($currentIndex)
    {
        $this->currentIndex = $currentIndex;
    }
    public function setArray($array)
    {
        $this->array = $array;
    }
    public function getCurrentIndex()
    {
        return $this->currentIndex;
    }
    public function getArray()
    {
        return $this->array;
    }
    public function key()
    {
        return $this->currentIndex;
    }
    public function next()
    {
        ++$this->currentIndex;
    }
    public function rewind()
    {
        $this->currentIndex = 0;
    }
    public function valid()
    {
        return isset($this->array[$this->currentIndex]);
    }
}

class Cycle implements IteratorAggregate
{
    protected $array;
    public function __construct($array)
    {
        $this->array = $array;
    }
    public function getIterator()
    {
        return new CycleIterator($this->array);
    }
}
$list = [1,2,3,4,5,6,7,8,9];
$cycle= new CycleIterator($list);
foreach ($cycle as $value){
    echo $value.PHP_EOL;
}

php 设计模式六大原则 php 设计模式六大原则 单一职责原则 里氏替换原则 依赖倒置原则 接口隔离原则 迪米特法则 开闭原则 word版 立即下载

相关推荐

PHP面向对象五大原则之开放-封闭原则(OCP)详解

本文实例讲述了PHP面向对象五大原则之开放-封闭原则(OCP)。分享给大家供大家参考,具体如下: 1. 什么是“开放-封闭” 随着软件系统规模的不断增大,软件系统的维护和修改的复杂性不断提高,这种困境促使法国工程院士Bertrand Meyer在1998年提出了“开放-封闭”(Open-Close Principle,OCP)原则,这条原则的基本思想是: Open(Open for extendtion)模块的行为必须是开放的、支持扩展的,而不是僵化的。 Close(Closed for modification)在对模块的功能进行扩展时,不应该影响或大规模地影响已有的模块。 换句话说,也就是

php设计模式六大原则,设计模式六大原则是什么

设计模式六大原则:1、单一原则;2、里氏替换原则;3、依赖倒置原则;4、接口隔离原则;5、迪米特原则;6、开闭原则。本文操作环境:Windows7系统,Dell G3电脑。设计模式六大原则:1、单一原则(Single Responsibility Principle):一个类或者一个方法只负责一项职责,尽量做到类的只有一个行为原因引起变化;a、业务对象(BO business object)、业务...

weixin_36429993的博客 655

腾讯会议视频过期了怎么办?亲测可用:用这个免费插件抢救你的会议录制与回放

本文提供了三种亲测有效的腾讯会议视频过期恢复方案,包括浏览器缓存提取、专业工具组合及预防性措施。特别推荐使用免费插件抢救过期会议录制与回放,帮助职场人解决重要视频资料丢失的难题。

weixin_33686714的博客 272

PHP-设计模式的六大原则

1、单一职责原则(Single Responsibility Principle,简称SRP ) 有且只有一个原因可引起类的变更。完成单一职责,用职责来衡量类设计是否优良。 2、里氏替换原则(Liskov Substitution Principle,简称LSP) 子类可完美替换基类,只要父类可以出现的地方,子类就可以出现,反之父类未必可以替换子类。增强程序的健壮性,即使增加了子类,原有子类还可以继续运行。子类对父类的方法尽量不要重写和重载。因为父类代表了定义好的结构,通过这个规范的接...

firesea的专栏 375

SPSS中的数据分析—信度效度检验【1】

前一段时间跟大家分享了好几篇关于EXCEL方面的数据分析知识,不知道大家都掌握得怎么样了。今天咱们换个口味,给大家讲一下关于SPSS中的数据分析——信度效度检验。 现阶段正处在毕业季阶段,很多同学可能都正在忙着去弄自己的论文和答辩(不知道大家在翟天临上热搜这个事情上有没有做出过一定贡献),很多时候我们在写论文答辩甚至于其他课题研究的时候都会选择用问卷这种形式来收集数据。最后我们只需要针对问卷所取...

小白数据营的博客 6万+

C语言手写HTTPD网站服务器

零基础手写C语言http网站服务器,快速入门C/C++后端开发、服务器开发。

程序员Rock的博客 1万+

PHP 基本知识点介绍

PHP 基本知识点介绍。本篇仅是简单讲一下PHP最基础的语法,其他的语法就不多说了,可以去参考官方文档,或者菜鸟教程,下一篇主要把一些常用的函数整理一下,方便查询。

weixin_43844718的博客 8040

B站充电视频下载器(需配合会员Cookie使用,仅供学习交流,Python)

这个程序是一个用于下载B站充电视频的工具,依赖于用户提供的会员Cookies。

qq_40753021的博客 2万+

php面向对象编程6大原则+3大类型+9大设计模式

一、面向对象编程的6大设计原则单一职责原则——类要职责单一,一个类只需要做好一件事情。里氏替换原则——子类可以扩展父类的功能,但不能改变父类原有的功能(可以实现父类的抽象方法和增加自己特有的方法,不要覆盖父类的非抽象方法)。依赖倒置原则——-面向接口编程:只需关心接口,不需要关心实现。接口隔离原则——-建立单一接口,尽量细化接口,接口中的方法尽量少。低耦合高内聚。最少知识原则——-一个类...

wuhuagu_wuhuaguo的博客 5436

xHCI驱动学习(1) 核心数据结构

虽然Linux内核拥有C语言构建的身体,但它骨子里散发的是面向对象的气质,这一个个的对象就是struct。面对一个内核模块的时候,首先要找出关键的struct和它们之间的关系,才能摸清代码的骨骼脉络。今天来理清USB xHCI相关的数据结构类型usb_hcd、xhci_hcd、hc_driver和全局变量xhci_pci_driver、xhci_hc_driver、xhci_pci_hc_driver之间的关系。

1万+

第229篇 轨迹时间参数化——TOPP-RA和速度约束处理

本文介绍了时间最优路径参数化(TOPP)问题及其解法。TOPP研究如何在给定空间路径上分配时间,使机器人运动时间最短且不超速,需满足速度、加速度和力矩约束。经典解法采用相平面法,通过前向和后向扫描确定最优速度曲线。TOPP-RA改进了数值稳定性,支持多约束处理。文章对比了TOPP与轨迹优化的区别,列举了开源工具,并解答了面试常见问题,指出TOPP广泛应用于机械臂、AGV等领域。TOPP不改变路径形状,仅优化速度分配,其最优解具有bang-bang特性。

郑伟强dev的专栏 328

PHP设计模式六大原则详细讲解

1、单一职责原则 理解: 单一职责适用于接口、类、方法,只负责一项职责 优点: 降低类的复杂度,一个类只负责一项职责,逻辑简单 提高类的可读性 可维护性提高:可读性提高,那当然更容易维护了 降低变更引起的风险:如果接口的单一职责做得好,一个接口修改只对相应的实现类有影响,对其他的接口无影响,这对系统的扩展性、维护性都有非常大的帮助 2、开闭原则 理解: 一个软件实体如类、函数应该对扩展开...

猿分已尽的博客 401

【MATLAB代码】UKF组合导航例程,15维状态量、3维观测量。附完整的代码,有中文注释、误差输出图像

摘要 本文提出了一种基于15维误差状态模型的UKF组合导航算法,实现了三维位置、速度和姿态的高精度估计。算法采用严格的误差状态模型,包含位置(3)、速度(3)、姿态(3)、陀螺偏差(3)和加速度计偏差(3)共15个状态量,通过3维GNSS位置观测进行校正。仿真结果表明,相比纯IMU积分,UKF算法能有效抑制误差积累,显著提高导航精度。文中提供了完整的MATLAB源代码,可直接运行并复现三维轨迹对比、位置/速度曲线及误差分析结果。

985工科博士毕业,专攻定位、导航和滤波等算法研究。从业10年,主要使用MATLAB 313

设计模式六大原则

使⽤建议:⼦类必须完全实现⽗类的⽅法,孩⼦类可以有⾃⼰的个性。⽤例:跑步运动员类-会跑步,⼦类⻓跑运动员-会跑步且擅⻓⻓跑, ⼦类短跑运动员-会跑步且擅⻓短跑。⽤例:修改密码,不应该提供修改⽤⼾信息接⼝,⽽就是单⼀的最⼩修改密码接⼝,更不要暴 露数据库操作。⽤例:⽼师让班⻓点名--⽼师给班⻓⼀个名单,班⻓完成点名勾选,返回结果,⽽不是班⻓点。使⽤建议:两个完全不⼀样的功能不应该放⼀个类中,⼀个类中应该是⼀组相关性很⾼的函。客⼾端不应该依赖它不需要的接⼝,类间的依赖关系应该建⽴在最⼩的接⼝上。

小胡同学的博客 507

《Linux GPU 驱动核心机制:面向图形与 AI 计算的 DRM 内存管理与任务调度》 目录

本文以缓冲区对象(BO)生命周期为主线,系统解析 Linux DRM 子系统中 GPU 驱动的核心机制。涵盖 GEM 与 TTM 内存管理、dma-buf/dma-fence 共享同步、GPU 调度与地址空间管理,结合 amdgpu、Xe 等驱动代码,深入剖析其设计动机与实现逻辑。旨在填补中文领域对 GPU 内核机制系统性讲解的空白,为图形与 AI 计算场景下的内存泄漏、同步死锁等疑难问题提供可追溯的分析路径。

图形/计算GPU的驱动与虚拟化技术分享园地 3791

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

设计模式六大原则的理解

梳理设计模式中的六大原则,阐述依赖倒置原则的含义

蒋大钊的博客 578

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

设计模式的六大原则

设计模式的六大原则          1、开闭原则(Open Close Principle)          2、里氏代换原则(Liskov Substitution Principle)          3、依赖倒转原则(Depend

编码小波的博客 1896

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

Java设计模式六大原则或者说七大原则

设计模式原则概念介绍

俊墨客 683

设计模式之六大原则

1.单一职责原则 每一个类只负责一个方法,降低类的复杂性,增强类的易读性、可维护性 2.开闭原则 需要增加某个功能时,不要在原有类的基础上去修改代码,在原有的基础上去扩展,用开闭原则最好的方法就是抽象,这样未来在增加某个功能时,可在原有的基础上实现,不改变原代码 3.里式替换原则 子类可以扩展父类原有的功能,但是不能替换掉父类原有的功能,增强代码的健壮性 4.依赖倒置原则 上层模块不能依赖下层模块...

欢迎阅读程序猿小张的博客~ 350

设计模式-六大原则

当初作为小白,提到设计模式,就会觉得很高大上,很牛叉。其实,在我们身边,在我们的项目中,设计模式的身影无处不在。然而,什么是设计模式呢?百度解释为:设计模式(Design Pattern)是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。 经验总是值得学习的,特别是对我们编程有极大帮助的设计模式经验。在Java中常见的设计模式有23种,而这23种设计模式都遵循了设计模式的六大原则,这......

笔沫拾光 703

Java设计模式六大原则

参考:http://www.uml.org.cn/sjms/201211023.asp 目录 设计模式六大原则(1):单一职责原则 设计模式六大原则(2):里氏替换原则 设计模式六大原则(3):依赖倒置原则 设计模式六大原则(4):接口隔离原则 设计模式六大原则(5):迪米特法则 设计模式六大原则(6):开闭原则 设计模式六大原则(1):单一职责原则 定义:不要存在多于一个...

雪落南城的博客 608
上一篇: 用tp6写的简单的eml的登录和curd
下一篇: 面试题-3.20
fengfeiyeqi
博客等级 码龄10年 456粉丝 38原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值
⌂ 换网址