不知有晋

<?php
abstract class facade
{
    protected abstract static function getFacadeClass();

    protected static function createFacade()
    {
        $facadeClass = static::getFacadeClass();
        include_once "{$facadeClass}.php";
        return new $facadeClass();
    }
    
    public static function __callstatic($method,$params)
    {
        call_user_func_array([static::createFacade(),$method],$params);
    }
}

<?php
class test1
{
    public function index($name)
    {
        echo "test1,name={$name}";
    }
}

<?php
include_once 'facade.php';
class test1facade extends facade
{
    protected static function getFacadeClass()
    {
        return 'test1';
    }
}

<?php
include 'test1facade.php';
include 'test2facade.php';
echo test1facade::index('Jerry');
echo test2facade::index('Page');

<?php
interface Shoes
{
    public function whoami();
}

class ShoesBasketball implements Shoes
{
    public function whoami()
    {
        return "I am Basketball shoes.";
    }
}

class ShoesRunning implements Shoes
{
    public function whoami()
    {
        return "I am Running shoes.";
    }
}

interface Factory
{
    public static function makeShoes():Shoes;
}
class FactoryBasketball implements Factory
{
    public static function makeShoes():ShoesBasketball
    {
        return new ShoesBasketball();
    }
}
class FactoryRunning implements Factory
{
    public static function makeShoes():ShoesRunning
    {
        return new ShoesRunning();
    }
}

$shoes = FactoryBasketball::makeShoes();
echo $shoes->whoami();
$shoes = FactoryRunning::makeShoes();
echo $shoes->whoami();

/**
 *  Test1 类
 */ 
class Test1
{
    private $id;
    public $name;

    public function __construct(int $id,string $name)
    {
        $this->id = $id;
        $this->name = $name;
    }
    public function getId()
    {
        return $this->id;
    }
    public function getName()
    {
        return $this->name;
    }

}

// 初始化 ReflectionClass 类
function getReflectObject($class)
{
    try {
        return new ReflectionClass($class);
    } catch (ReflectionException $e) {
        throw new ClassNotFoundException('class not exists: ' . $class, $class, $e);
    }
}

// 实例化类后调用方法
function invokeClass_1(string $class,array $args)
{
    $reflect = getReflectObject($class);
    // 创建一个类的新实例，给出的参数将传递到类的构造函数。
    $object = $reflect->newInstanceArgs($args);

    //  获取类的属性，返回ReflectionProperty 对象的数组。
    $props = $reflect->getProperties();
    foreach ($props as $prop) {
        // 输出属性变量名和指定实例的属性值
        echo $prop->getName() . "=".$prop->getValue($object)."\n";
    }
    // 类实例直接调用方法
    $name = $object->getName();

    return $name;
}

$res = invokeClass_1('Test1',[1,'Jerry']);
var_dump($res);

/**
 * Test2 类
 */
class Test2
{
    private $id;
    public $name;
    private static $_instance;

    private function __construct(int $id,string $name)
    {
        $this->id = $id;
        $this->name = $name;
    }

    // 把构造函数 __construct 改成 private，并增加 getInstance 方法
    public static function getInstance(int $id,string $name)
    {
        if(empty(self::$_instance))
            self::$_instance = new static($id,$name);
            
        return self::$_instance;
    }

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

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

    public static function sayHi($id,$name)
    {
        return "hello {$name}, your id={$id}.";
    }

    public static function index()
    {
        return "hello index";
    }

}

// 初始化 ReflectionClass 类
function getReflectObject($class)
{
    try {
        return new ReflectionClass($class);
    } catch (ReflectionException $e) {
        throw new ClassNotFoundException('class not exists: ' . $class, $class, $e);
    }
}

// 调用静态方法
function invokeClass_2(string $class,array $args)
{
    $reflect = getReflectObject($class);
    $name = null;
    // 检查类中是否存在指定的方法
    if ($reflect->hasMethod('getInstance')) {
        // 获取一个类方法的 ReflectionMethod。
        $method = $reflect->getMethod('getInstance');
        if ($method->isPublic() && $method->isStatic()) {
            // 使用数组给方法传送参数，并执行他。
            $object = $method->invokeArgs(null, $args);
            $name = $object->getName();
        }
    }
    return $name;
}

$res = invokeClass_2('Test2',[2,'Sam']);
var_dump($res);

// 初始化 ReflectionMethod 类
function getReflectMethodObject($class,$name)
{
    try {
        return new ReflectionMethod($class,$name);
    } catch (ReflectionException $e) {
        throw new ClassNotFoundException('class or method not exists: ' . $class, $class, $e);
    }
}

// 调用静态方法
function invokeMethod_1(string $class,string $name,array $args)
{
    $method = getReflectMethodObject($class,$name);
    // 获取方法定义的参数数目，包括可选参数
    $num = $method->getNumberOfParameters();
    if($num > 0)
        // 使用数组给方法传送参数，并执行他。
        $res = $method->invokeArgs(null,$args);
    else
        // 执行一个反射的方法。
        $res = $method->invoke(null);
    
    return $res;
}
$res = invokeMethod_1('Test2','sayHi',[2,'Sam']);
var_dump($res);

$res = call_user_func_array([__NAMESPACE__.'Test2','sayHi'],[2,'Sam']); 

$res = invokeMethod_1('Test2','index',[]);
var_dump($res);

$res = call_user_func([__NAMESPACE__.'Test2','index']);

// 一个处理数据的方法
function processUserData($name, $age, $job = "", $hobbie = "")
{
    $msg = "Hello $name. You have $age years old";
    if (!empty($job)) {
    $msg .= ". Your job is $job";
    }

    if (!empty($hobbie)) {
        $msg .= ". Your hobbie is $hobbie";
    }

    return $msg . ".";
}

$refFunction = new ReflectionFunction('processUserData');
$valuesToProcess = [
    'name' => 'Anderson Lucas Silva de Oliveira',
    'age' => 21,
    'hobbie' => 'Play games'
  ];
$res = $refFunction->invoke(...$valuesToProcess);
var_dump($res);

// 通过反射调用函数或者类方法
function invoke($class,$function,$args)
{
    if(function_exists($function))
    {
        $refFunction = new ReflectionFunction($function);
        $res = $refFunction->invoke(...$args);
    }else{
        $reflect = getReflectObject($class);
        $constructor = $reflect->getConstructor();
        // 构造函数是公有的
        if($constructor->isPublic())
        {
            $object = $reflect->newInstanceArgs($args);
        }else if($reflect->hasMethod('getInstance')){
            // 当构造函数为 private ，则通过 getInstance 方法获取类的实例
            $method = $reflect->getMethod('getInstance');
            if ($method->isPublic() && $method->isStatic()) 
                // 使用数组给方法传送参数，并执行他。
                $object = $method->invokeArgs(null, $args);
            
        }
        $res = $object->$function();
    }
    return $res;
}

$valuesToProcess = [
    'name' => 'Anderson Lucas Silva de Oliveira',
    'age' => 21,
    'hobbie' => 'Play games'
  ];

$res = invoke(null,'processUserData',$valuesToProcess);
// $res = invoke('Test1','getName',[2,'Sam']);
// $res = invoke('Test2','getName',[1,'Jerry']);

var_dump($res);

$res = invoke(null,'processUserData',$valuesToProcess);

$res = invoke('Test1','getName',[2,'Sam']);

$res = invoke('Test2','getName',[1,'Jerry']);