Php 什么时候使用静态方法还是简单类方法？

我不知道是使用静态方法还是简单方法

让我举个例子，我正在使用Zend framework 1项目。
我有一节课

class Example1
{
    public static function getVariable() {
       return is_numeric(Zend_Registry::get('config')->Variable) ? Zend_Registry::get('config')->Variable : 0;
    }

    public function calculateSome($param1, $param2) {
        $response = array();
        if($param2 == 0) { 
              $response = number_format(($param1 * self::getvariable()) /100);
        } else {
              $response = $param1;
        }
        return $response;
    }
}

用法：

目前，我在整个项目中获得了变量值，如

Example1:：getVariable（）

和计算类似，首先实例化一个类

$class1=newexample1（）$class1->calculateSome（1，0）

---

我不知道将

calculateSome（）

更改为

并像这样调用

Example1:：calculateSome（1，0）

还是保持原样是好的

我找到了何时使用static=>

---

但是我不明白它说的是什么。

当方法涉及基于实例的属性/更改时，你应该保持它

非静态

如果它是整个
类型所需的方法，则使用static

例如，您可以跟踪此代码段创建的实例：

class Product {
 static $count;
 private $name;

 public function __construct($name) {
    $this->name = $name;
    self::$count++;
 }
 public function getName() {
    return $this->name;
 }
 public static function getCount() {
     return self:$count;
 }
}

$productA = new Product('A');
$productB = new Product('B');

echo $productA->getName(). ' and ' . $productB->getName(). '<br />'. PHP_EOL;
echo 'Total made products :' . Product::getCount();

类产品{
静态$计数；
私人$name；
公共函数构造（$name）{
$this->name=$name；
self:：$count++；
}
公共函数getName（）{
返回$this->name；
}
公共静态函数getCount（）{
返回自计数；
}
}
$productA=新产品（'A'）；
$productB=新产品（'B'）；
echo$productA->getName（）和'$productB->getName（）
。PHP_EOL；
echo“全部制造产品：”。Product:：getCount（）；
当方法涉及基于实例的属性/更改时，您应将其保持为非静态的

如果它是整个
类型所需的方法，则使用static

例如，您可以跟踪此代码段创建的实例：

class Product {
 static $count;
 private $name;

 public function __construct($name) {
    $this->name = $name;
    self::$count++;
 }
 public function getName() {
    return $this->name;
 }
 public static function getCount() {
     return self:$count;
 }
}

$productA = new Product('A');
$productB = new Product('B');

echo $productA->getName(). ' and ' . $productB->getName(). '<br />'. PHP_EOL;
echo 'Total made products :' . Product::getCount();

类产品{
静态$计数；
私人$name；
公共函数构造（$name）{
$this->name=$name；
self:：$count++；
}
公共函数getName（）{
返回$this->name；
}
公共静态函数getCount（）{
返回自计数；
}
}
$productA=新产品（'A'）；
$productB=新产品（'B'）；
echo$productA->getName（）和'$productB->getName（）
。PHP_EOL；
echo“全部制造产品：”。Product:：getCount（）；
当方法涉及基于实例的属性/更改时，您应将其保持为非静态的

如果它是整个
类型所需的方法，则使用static

例如，您可以跟踪此代码段创建的实例：

class Product {
 static $count;
 private $name;

 public function __construct($name) {
    $this->name = $name;
    self::$count++;
 }
 public function getName() {
    return $this->name;
 }
 public static function getCount() {
     return self:$count;
 }
}

$productA = new Product('A');
$productB = new Product('B');

echo $productA->getName(). ' and ' . $productB->getName(). '<br />'. PHP_EOL;
echo 'Total made products :' . Product::getCount();

类产品{
静态$计数；
私人$name；
公共函数构造（$name）{
$this->name=$name；
self:：$count++；
}
公共函数getName（）{
返回$this->name；
}
公共静态函数getCount（）{
返回自计数；
}
}
$productA=新产品（'A'）；
$productB=新产品（'B'）；
echo$productA->getName（）和'$productB->getName（）
。PHP_EOL；
echo“全部制造产品：”。Product:：getCount（）；
当方法涉及基于实例的属性/更改时，您应将其保持为非静态的

如果它是整个
类型所需的方法，则使用static

例如，您可以跟踪此代码段创建的实例：

class Product {
 static $count;
 private $name;

 public function __construct($name) {
    $this->name = $name;
    self::$count++;
 }
 public function getName() {
    return $this->name;
 }
 public static function getCount() {
     return self:$count;
 }
}

$productA = new Product('A');
$productB = new Product('B');

echo $productA->getName(). ' and ' . $productB->getName(). '<br />'. PHP_EOL;
echo 'Total made products :' . Product::getCount();

类产品{
静态$计数；
私人$name；
公共函数构造（$name）{
$this->name=$name；
self:：$count++；
}
公共函数getName（）{
返回$this->name；
}
公共静态函数getCount（）{
返回自计数；
}
}
$productA=新产品（'A'）；
$productB=新产品（'B'）；
echo$productA->getName（）和'$productB->getName（）
。PHP_EOL；
echo“全部制造产品：”。Product:：getCount（）；
您可以在这里找到详细答案：

TL；它的DR版本是：


静态方法只不过是一个命名空间函数，
Foo:：bar（）
与
Foo\u bar（）
没有显著区别
无论何时调用静态方法或函数，都是在硬编码依赖项。读取
$bar=Foo:：bar（）的代码对特定的
Foo
类具有硬编码依赖关系。如果不更改源代码的该部分，就不可能更改
Foo
所指的内容

对象是“软”依赖项<代码>$bar=$foo->bar（）
是灵活的，它允许更改
$foo
所指的内容。您可以将其与依赖项注入一起使用，以将代码与其他代码解耦：

function baz(Foo $foo) {
    $bar = $foo->bar();
    ...
}


您可以随时随地调用
Foo:：bar（）。如果
Foo:：bar
有它所依赖的依赖项，则很难保证在调用该方法时该依赖项可用。需要对象实例化需要运行对象的构造函数，这可以强制要求设置对象的其余方法所依赖的需求

构造函数和依赖项注入对象到其他函数中对于

在代码库中创建接缝，使其能够“拆开”，并以灵活的方式组合在一起
将检查放在战略位置，以确保满足代码某些部分的要求（在对象实例化时，构造函数强制执行其世界一小部分的正常状态，即其对象），这使得定位和包含故障变得更加容易
把它想象成将你的应用程序划分开来，在每个隔间之间放置防火墙，每个隔间都有一个主管负责；而不是每个人都在同一个房间里跑来跑去

无论何时编写
新类
，您都可以编写
类：：staticMethod（）
，硬编码依赖项是相同的

因此，决定归结为：


这门课的要求是什么？在运行任何代码之前，是否需要确保满足某些先决条件（例如。