创建单独的设计图案在PHP5
https://stackoverflow.com/questions/203336
-
03-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian题
怎么会一个创建一个单独的类使用PHP5类？
解决方案
/**
* Singleton class
*
*/
final class UserFactory
{
/**
* Call this method to get singleton
*
* @return UserFactory
*/
public static function Instance()
{
static $inst = null;
if ($inst === null) {
$inst = new UserFactory();
}
return $inst;
}
/**
* Private ctor so nobody else can instantiate it
*
*/
private function __construct()
{
}
}
使用：
$fact = UserFactory::Instance();
$fact2 = UserFactory::Instance();
$ fact == $ fact2;
可是：
$fact = new UserFactory()
引发错误。
参见 http://php.net/manual/en/language.variables.scope.php#language.variables.scope.static 来理解静态变量范围以及为什么设置 static $ inst = null; 有效。
其他提示
PHP 5.3允许通过后期静态绑定创建可继承的Singleton类：
class Singleton
{
protected static $instance = null;
protected function __construct()
{
//Thou shalt not construct that which is unconstructable!
}
protected function __clone()
{
//Me not like clones! Me smash clones!
}
public static function getInstance()
{
if (!isset(static::$instance)) {
static::$instance = new static;
}
return static::$instance;
}
}
这解决了这个问题，在PHP 5.3之前，任何扩展Singleton的类都会生成其父类的实例而不是它自己的实例。
现在你可以做到：
class Foobar extends Singleton {};
$foo = Foobar::getInstance();
$ foo将是Foobar的一个实例而不是Singleton的实例。
不幸的是 Inwdr的答案在有多个子类。
这是一个正确的可继承Singleton基类。
class Singleton
{
private static $instances = array();
protected function __construct() {}
protected function __clone() {}
public function __wakeup()
{
throw new Exception("Cannot unserialize singleton");
}
public static function getInstance()
{
$cls = get_called_class(); // late-static-bound class name
if (!isset(self::$instances[$cls])) {
self::$instances[$cls] = new static;
}
return self::$instances[$cls];
}
}
测试代码：
class Foo extends Singleton {}
class Bar extends Singleton {}
echo get_class(Foo::getInstance()) . "\n";
echo get_class(Bar::getInstance()) . "\n";
制作Singleton Pattern的Real One和Modern 方法是：
<?php
/**
* Singleton Pattern.
*
* Modern implementation.
*/
class Singleton
{
/**
* Call this method to get singleton
*/
public static function instance()
{
static $instance = false;
if( $instance === false )
{
// Late static binding (PHP 5.3+)
$instance = new static();
}
return $instance;
}
/**
* Make constructor private, so nobody can call "new Class".
*/
private function __construct() {}
/**
* Make clone magic method private, so nobody can clone instance.
*/
private function __clone() {}
/**
* Make sleep magic method private, so nobody can serialize instance.
*/
private function __sleep() {}
/**
* Make wakeup magic method private, so nobody can unserialize instance.
*/
private function __wakeup() {}
}
现在你可以像使用它一样使用它。
<?php
/**
* Database.
*
* Inherited from Singleton, so it's now got singleton behavior.
*/
class Database extends Singleton {
protected $label;
/**
* Example of that singleton is working correctly.
*/
public function setLabel($label)
{
$this->label = $label;
}
public function getLabel()
{
return $this->label;
}
}
// create first instance
$database = Database::instance();
$database->setLabel('Abraham');
echo $database->getLabel() . PHP_EOL;
// now try to create other instance as well
$other_db = Database::instance();
echo $other_db->getLabel() . PHP_EOL; // Abraham
$other_db->setLabel('Priler');
echo $database->getLabel() . PHP_EOL; // Priler
echo $other_db->getLabel() . PHP_EOL; // Priler
如你所见，这种认识更加灵活。
您可能应该添加一个私有__clone（）方法来禁止克隆实例。
private function __clone() {}
如果您不包含此方法，则可以使用以下方法
$inst1=UserFactory::Instance(); // to stick with the example provided above
$inst2=clone $inst1;
现在 $ inst1 ！== $ inst2 - 它们不再是同一个实例。
<?php
/**
* Singleton patter in php
**/
trait SingletonTrait {
protected static $inst = null;
/**
* call this method to get instance
**/
public static function getInstance(){
if (static::$inst === null){
static::$inst = new static();
}
return static::$inst;
}
/**
* protected to prevent clonning
**/
protected function __clone(){
}
/**
* protected so no one else can instance it
**/
protected function __construct(){
}
}
使用：
/**
* example of class definitions using SingletonTrait
*/
class DBFactory {
/**
* we are adding the trait here
**/
use SingletonTrait;
/**
* This class will have a single db connection as an example
**/
protected $db;
/**
* as an example we will create a PDO connection
**/
protected function __construct(){
$this->db =
new PDO('mysql:dbname=foodb;port=3305;host=127.0.0.1','foouser','foopass');
}
}
class DBFactoryChild extends DBFactory {
/**
* we repeating the inst so that it will differentiate it
* from UserFactory singleton
**/
protected static $inst = null;
}
/**
* example of instanciating the classes
*/
$uf0 = DBFactoryChild::getInstance();
var_dump($uf0);
$uf1 = DBFactory::getInstance();
var_dump($uf1);
echo $uf0 === $uf1;
respose：
object(DBFactoryChild)#1 (0) {
}
object(DBFactory)#2 (0) {
}
如果您使用PHP 5.4： trait 这是一个选项，那么您不必浪费继承层次结构才能拥有 单身人士模式
并注意到您是否使用 traits 或 扩展Singleton 类 如果你不添加以下代码行，那么一个松散的结局是创建子类的单例：
protected static $inst = null;
在子课程中
意外的结果将是：
object(DBFactoryChild)#1 (0) {
}
object(DBFactoryChild)#1 (0) {
}
protected static <*>
此代码可以适用于任何类而无需关心其类名。
instance;
public static function getInstance()
{
if(is_null(self::<*>
此代码可以适用于任何类而无需关心其类名。
instance))
{
self::<*>
此代码可以适用于任何类而无需关心其类名。
instance = new self();
}
return self::<*>
此代码可以适用于任何类而无需关心其类名。
instance;
}
此代码可以适用于任何类而无需关心其类名。
支持每个类别1行的多个对象：
这个方法会对你想要的任何一个类强制执行单例，你要做的就是在你想要制作一个单例的类中添加一个方法，这样就可以为你做。
这也将对象存储在“SingleTonBase”中。 class，这样你就可以通过递归 SingleTonBase 对象来调试你在系统中使用的所有对象。
创建一个名为SingletonBase.php的文件，并将其包含在脚本的根目录中！
代码是
abstract class SingletonBase
{
private static $storage = array();
public static function Singleton($class)
{
if(in_array($class,self::$storage))
{
return self::$storage[$class];
}
return self::$storage[$class] = new $class();
}
public static function storage()
{
return self::$storage;
}
}
然后，对于任何想要制作单身的班级，只需添加这个小单一方法。
public static function Singleton()
{
return SingletonBase::Singleton(get_class());
}
这是一个小例子：
include 'libraries/SingletonBase.resource.php';
class Database
{
//Add that singleton function.
public static function Singleton()
{
return SingletonBase::Singleton(get_class());
}
public function run()
{
echo 'running...';
}
}
$Database = Database::Singleton();
$Database->run();
你可以在任何一个类中添加这个单例函数，每个类只创建一个实例。
注意：您应该始终使__construct为private以消除使用新的Class（）;实例
class Database{
//variable to hold db connection
private $db;
//note we used static variable,beacuse an instance cannot be used to refer this
public static $instance;
//note constructor is private so that classcannot be instantiated
private function __construct(){
//code connect to database
}
//to prevent loop hole in PHP so that the class cannot be cloned
private function __clone() {}
//used static function so that, this can be called from other classes
public static function getInstance(){
if( !(self::$instance instanceof self) ){
self::$instance = new self();
}
return self::$instance;
}
public function query($sql){
//code to run the query
}
}
Access the method getInstance using
$db = Singleton::getInstance();
$db->query();
你真的不需要使用Singleton模式，因为它被认为是反模式。基本上有很多理由不完全实现这种模式。阅读本文开头： PHP单例类的最佳实践。
如果您仍然认为您需要使用Singleton模式，那么我们可以编写一个类，通过扩展SingletonClassVendor抽象类来允许我们获得Singleton功能。
这就是我用来解决这个问题的方法。
<?php
namespace wl;
/**
* @author DevWL
* @dosc allows only one instance for each extending class.
* it acts a litle bit as registry from the SingletonClassVendor abstract class point of view
* but it provides a valid singleton behaviour for its children classes
* Be aware, the singleton pattern is consider to be an anti-pattern
* mostly because it can be hard to debug and it comes with some limitations.
* In most cases you do not need to use singleton pattern
* so take a longer moment to think about it before you use it.
*/
abstract class SingletonClassVendor
{
/**
* holds an single instance of the child class
*
* @var array of objects
*/
protected static $instance = [];
/**
* @desc provides a single slot to hold an instance interchanble between all child classes.
* @return object
*/
public static final function getInstance(){
$class = get_called_class(); // or get_class(new static());
if(!isset(self::$instance[$class]) || !self::$instance[$class] instanceof $class){
self::$instance[$class] = new static(); // create and instance of child class which extends Singleton super class
echo "new ". $class . PHP_EOL; // remove this line after testing
return self::$instance[$class]; // remove this line after testing
}
echo "old ". $class . PHP_EOL; // remove this line after testing
return static::$instance[$class];
}
/**
* Make constructor abstract to force protected implementation of the __constructor() method, so that nobody can call directly "new Class()".
*/
abstract protected function __construct();
/**
* Make clone magic method private, so nobody can clone instance.
*/
private function __clone() {}
/**
* Make sleep magic method private, so nobody can serialize instance.
*/
private function __sleep() {}
/**
* Make wakeup magic method private, so nobody can unserialize instance.
*/
private function __wakeup() {}
}
使用示例：
/**
* EXAMPLE
*/
/**
* @example 1 - Database class by extending SingletonClassVendor abstract class becomes fully functional singleton
* __constructor must be set to protected becaouse:
* 1 to allow instansiation from parent class
* 2 to prevent direct instanciation of object with "new" keword.
* 3 to meet requierments of SingletonClassVendor abstract class
*/
class Database extends SingletonClassVendor
{
public $type = "SomeClass";
protected function __construct(){
echo "DDDDDDDDD". PHP_EOL; // remove this line after testing
}
}
/**
* @example 2 - Config ...
*/
class Config extends SingletonClassVendor
{
public $name = "Config";
protected function __construct(){
echo "CCCCCCCCCC" . PHP_EOL; // remove this line after testing
}
}
只是为了证明它按预期工作：
/**
* TESTING
*/
$bd1 = Database::getInstance(); // new
$bd2 = Database::getInstance(); // old
$bd3 = Config::getInstance(); // new
$bd4 = Config::getInstance(); // old
$bd5 = Config::getInstance(); // old
$bd6 = Database::getInstance(); // old
$bd7 = Database::getInstance(); // old
$bd8 = Config::getInstance(); // old
echo PHP_EOL."COMPARE ALL DATABASE INSTANCES".PHP_EOL;
var_dump($bd1);
echo '$bd1 === $bd2' . ($bd1 === $bd2)? ' TRUE' . PHP_EOL: ' FALSE' . PHP_EOL; // TRUE
echo '$bd2 === $bd6' . ($bd2 === $bd6)? ' TRUE' . PHP_EOL: ' FALSE' . PHP_EOL; // TRUE
echo '$bd6 === $bd7' . ($bd6 === $bd7)? ' TRUE' . PHP_EOL: ' FALSE' . PHP_EOL; // TRUE
echo PHP_EOL;
echo PHP_EOL."COMPARE ALL CONFIG INSTANCES". PHP_EOL;
var_dump($bd3);
echo '$bd3 === $bd4' . ($bd3 === $bd4)? ' TRUE' . PHP_EOL: ' FALSE' . PHP_EOL; // TRUE
echo '$bd4 === $bd5' . ($bd4 === $bd5)? ' TRUE' . PHP_EOL: ' FALSE' . PHP_EOL; // TRUE
echo '$bd5 === $bd8' . ($bd5 === $bd8)? ' TRUE' . PHP_EOL: ' FALSE' . PHP_EOL; // TRUE
对我来说，所有这些复杂性（“后期静态绑定”...... harumph）只是PHP破坏的对象/类模型的标志。如果类对象是第一类对象（参见Python），那么“$ _ instance”也是如此。将是一个类实例变量 - 类对象的成员，而不是其实例的成员/属性，而不是由其后代共享。在Smalltalk世界中，这是“类变量”之间的差异。和“类实例变量”。
在PHP中，它看起来好像我们需要牢记指导模式是编写代码的指南 - 我们可能会想到一个Singleton模板，但是试图编写继承自实际的代码;辛格尔顿＆QUOT; class看起来被误导为PHP（虽然我认为一些有进取心的灵魂可以创建一个合适的SVN关键字）。
我将继续使用共享模板分别对每个单例进行编码。
请注意，我绝对不会讨论单身人士的讨论，生活太短暂。
我知道这可能会导致不必要的火焰战，但我可以看到你可能想要多个数据库连接，所以我会承认单身可能不是最好的解决方案...但是，我发现单身模式的其他用途非常有用。
这是一个例子：我决定推出自己的MVC和模板引擎，因为我想要一些非常轻量级的东西。但是，我要显示的数据包含许多特殊的数学字符，例如＆＃8805;和＆＃956;你有什么...数据存储为我的数据库中的实际UTF-8字符而不是HTML编码，因为我的应用程序除了HTML之外还可以提供其他格式，如PDF和CSV。格式化HTML的适当位置是在模板内部（如果愿意的话，“视图”），负责呈现该页面部分（片段）。我想将它们转换为适当的HTML实体，但PHP的get_html_translation_table（）函数并不是超级快。一次检索数据并作为数组存储更有意义，使所有人都可以使用它。这是我一起敲打测试速度的样本。据推测，无论您使用的其他方法（获取实例后）是否为静态，这都可以正常工作。
class EncodeHTMLEntities {
private static $instance = null;//stores the instance of self
private $r = null;//array of chars elligalbe for replacement
private function __clone(){
}//disable cloning, no reason to clone
private function __construct()
{
$allEntities = get_html_translation_table(HTML_ENTITIES, ENT_NOQUOTES);
$specialEntities = get_html_translation_table(HTML_SPECIALCHARS, ENT_NOQUOTES);
$this->r = array_diff($allEntities, $specialEntities);
}
public static function replace($string)
{
if(!(self::$instance instanceof self) ){
self::$instance = new self();
}
return strtr($string, self::$instance->r);
}
}
//test one million encodings of a string
$start = microtime(true);
for($x=0; $x<1000000; $x++){
$dump = EncodeHTMLEntities::replace("Reference method for diagnosis of CDAD, but clinical usefulness limited due to extended turnaround time (≥96 hrs)");
}
$end = microtime(true);
echo "Run time: ".($end-$start)." seconds using singleton\n";
//now repeat the same without using singleton
$start = microtime(true);
for($x=0; $x<1000000; $x++){
$allEntities = get_html_translation_table(HTML_ENTITIES, ENT_NOQUOTES);
$specialEntities = get_html_translation_table(HTML_SPECIALCHARS, ENT_NOQUOTES);
$r = array_diff($allEntities, $specialEntities);
$dump = strtr("Reference method for diagnosis of CDAD, but clinical usefulness limited due to extended turnaround time (≥96 hrs)", $r);
}
$end = microtime(true);
echo "Run time: ".($end-$start)." seconds without using singleton";
基本上，我看到了这样的典型结果：
php test.php Run time: 27.842966794968 seconds using singleton Run time: 237.78191494942 seconds without using singleton
因此，虽然我当然不是专家，但我没有看到一种更方便可靠的方法来减少某些数据的慢速调用开销，同时使其变得非常简单（单行代码来做你的事情）需要）。虽然我的例子只有一个有用的方法，因此并不比全局定义的函数好，但是只要你有两个方法，你就会想要将它们组合在一起，对吧？我离开基地了吗？
此外，我更喜欢实际做某些事情的例子，因为有时很难想象一个例子包含诸如“//做一些有用的事情”之类的陈述。我一直在寻找教程时看到的。
无论如何，我喜欢任何反馈或评论为什么使用单身人士这类事情是有害的（或过于复杂）。
这篇文章涵盖的主题的相当广泛:http://www.phptherightway.com/pages/Design-Patterns.html#singleton
注意以下几点：
- 构造
__construct()被宣布为protected防止创建新的实例之外的类通过new操作员。- 魔法的方法
__clone()被宣布为private防止性克隆类的一个实例通过clone操作员。- 魔法的方法
__wakeup()被宣布为private防止unserializing的类的一个实例通过全球功能unserialize().- 创建一个新实例通过后期静态约束力的建立的静态的方法
getInstance()与关键字static.此 允许继承的class Singleton在例子。
我已经写了很长时间以后想在这里分享
class SingletonDesignPattern {
//just for demo there will be only one instance
private static $instanceCount =0;
//create the private instance variable
private static $myInstance=null;
//make constructor private so no one create object using new Keyword
private function __construct(){}
//no one clone the object
private function __clone(){}
//avoid serialazation
public function __wakeup(){}
//ony one way to create object
public static function getInstance(){
if(self::$myInstance==null){
self::$myInstance=new SingletonDesignPattern();
self::$instanceCount++;
}
return self::$myInstance;
}
public static function getInstanceCount(){
return self::$instanceCount;
}
}
//now lets play with singleton design pattern
$instance = SingletonDesignPattern::getInstance();
$instance = SingletonDesignPattern::getInstance();
$instance = SingletonDesignPattern::getInstance();
$instance = SingletonDesignPattern::getInstance();
echo "number of instances: ".SingletonDesignPattern::getInstanceCount();
我同意第一个答案，但我也会将该类声明为final，因此无法扩展，因为扩展单例会违反单例模式。实例变量也应该是私有的，因此无法直接访问它。还要将__clone方法设为私有，以便您无法克隆单例对象。
下面是一些示例代码。
/**
* Singleton class
*
*/
final class UserFactory
{
private static 我同意第一个答案，但我也会将该类声明为final，因此无法扩展，因为扩展单例会违反单例模式。实例变量也应该是私有的，因此无法直接访问它。还要将__clone方法设为私有，以便您无法克隆单例对象。
下面是一些示例代码。
$user_factory = UserFactory::getInstance();
使用示例
$user_factory = UserFactory::我同意第一个答案，但我也会将该类声明为final，因此无法扩展，因为扩展单例会违反单例模式。实例变量也应该是私有的，因此无法直接访问它。还要将__clone方法设为私有，以便您无法克隆单例对象。
下面是一些示例代码。
/**
* Singleton class
*
*/
final class UserFactory
{
private static 我同意第一个答案，但我也会将该类声明为final，因此无法扩展，因为扩展单例会违反单例模式。实例变量也应该是私有的，因此无法直接访问它。还要将__clone方法设为私有，以便您无法克隆单例对象。
下面是一些示例代码。
$user_factory = UserFactory::getInstance();
使用示例
<*>
这会阻止你做什么（这会违反单身人士模式......
你不能这样做！
<*>instance = null;
/**
* Private constructor
*
*/
private function __construct() {}
/**
* Private clone method
*
*/
private function __clone() {}
/**
* Call this method to get singleton
*
* @return UserFactory
*/
public static function getInstance()
{
if (self::我同意第一个答案，但我也会将该类声明为final，因此无法扩展，因为扩展单例会违反单例模式。实例变量也应该是私有的，因此无法直接访问它。还要将__clone方法设为私有，以便您无法克隆单例对象。
下面是一些示例代码。
<*>
使用示例
<*>
这会阻止你做什么（这会违反单身人士模式......
你不能这样做！
<*>instance === null) {
self::我同意第一个答案，但我也会将该类声明为final，因此无法扩展，因为扩展单例会违反单例模式。实例变量也应该是私有的，因此无法直接访问它。还要将__clone方法设为私有，以便您无法克隆单例对象。
下面是一些示例代码。
<*>
使用示例
<*>
这会阻止你做什么（这会违反单身人士模式......
你不能这样做！
<*>instance = new UserFactory();
}
return self::我同意第一个答案，但我也会将该类声明为final，因此无法扩展，因为扩展单例会违反单例模式。实例变量也应该是私有的，因此无法直接访问它。还要将__clone方法设为私有，以便您无法克隆单例对象。
下面是一些示例代码。
<*>
使用示例
<*>
这会阻止你做什么（这会违反单身人士模式......
你不能这样做！
<*>instance;
}
}
使用示例
<*>
这会阻止你做什么（这会违反单身人士模式......
你不能这样做！
<*>instance;
class SecondUserFactory extends UserFactory { }
这会阻止你做什么（这会违反单身人士模式......
你不能这样做！
<*>instance = null;
/**
* Private constructor
*
*/
private function __construct() {}
/**
* Private clone method
*
*/
private function __clone() {}
/**
* Call this method to get singleton
*
* @return UserFactory
*/
public static function getInstance()
{
if (self::我同意第一个答案，但我也会将该类声明为final，因此无法扩展，因为扩展单例会违反单例模式。实例变量也应该是私有的，因此无法直接访问它。还要将__clone方法设为私有，以便您无法克隆单例对象。
下面是一些示例代码。
<*>
使用示例
<*>
这会阻止你做什么（这会违反单身人士模式......
你不能这样做！
<*>instance === null) {
self::我同意第一个答案，但我也会将该类声明为final，因此无法扩展，因为扩展单例会违反单例模式。实例变量也应该是私有的，因此无法直接访问它。还要将__clone方法设为私有，以便您无法克隆单例对象。
下面是一些示例代码。
<*>
使用示例
<*>
这会阻止你做什么（这会违反单身人士模式......
你不能这样做！
<*>instance = new UserFactory();
}
return self::我同意第一个答案，但我也会将该类声明为final，因此无法扩展，因为扩展单例会违反单例模式。实例变量也应该是私有的，因此无法直接访问它。还要将__clone方法设为私有，以便您无法克隆单例对象。
下面是一些示例代码。
<*>
使用示例
<*>
这会阻止你做什么（这会违反单身人士模式......
你不能这样做！
<*>instance;
}
}
使用示例
<*>这会阻止你做什么（这会违反单身人士模式......
你不能这样做！
<*>这应该是Singleton的正确方法。
class Singleton {
private static $instance;
private $count = 0;
protected function __construct(){
}
public static function singleton(){
if (!isset(self::$instance)) {
self::$instance = new Singleton;
}
return self::$instance;
}
public function increment()
{
return $this->count++;
}
protected function __clone(){
}
protected function __wakeup(){
}
}
我喜欢@ jose-segura使用traits的方法，但不喜欢在子类上定义静态变量的需要。下面的解决方案通过将静态局部变量中的实例缓存到由类名索引的工厂方法来避免它：
<?php
trait Singleton {
# Single point of entry for creating a new instance. For a given
# class always returns the same instance.
public static function instance(){
static $instances = array();
$class = get_called_class();
if( !isset($instances[$class]) ) $instances[$class] = new $class();
return $instances[$class];
}
# Kill traditional methods of creating new instances
protected function __clone() {}
protected function __construct() {}
}
用法与@ jose-segura相同，只需要子类中的静态变量。
检查是否存在任何现有数据库实例的数据库类，它将返回先前的实例。
class Database {
public static $instance;
public static function getInstance(){
if(!isset(Database::$instance) ) {
Database::$instance = new Database();
}
return Database::$instance;
}
private function __cunstruct() {
/* private and cant create multiple objects */
}
public function getQuery(){
return "Test Query Data";
}
}
$dbObj = Database::getInstance();
$dbObj2 = Database::getInstance();
var_dump($dbObj);
var_dump($dbObj2);
/*
After execution you will get following output:
object(Database)[1]
object(Database)[1]
*/
参考 http://www.phptechi.com/php-singleton - 设计图案-example.html的
这是在数据库类
上创建单例的示例设计模式 1）单身人士
class Database{
public static $instance;
public static function getInstance(){
if(!isset(Database::$instance)){
Database::$instance=new Database();
return Database::$instance;
}
}
$db=Database::getInstance();
$db2=Database::getInstance();
$db3=Database::getInstance();
var_dump($db);
var_dump($db2);
var_dump($db3);
然后输出是 -
object(Database)[1]
object(Database)[1]
object(Database)[1]
仅使用单个实例不创建3个实例
这是我的示例，它提供了调用$ var = new Singleton（）的能力，并且还创建了3个变量来测试它是否创建了新对象：
class Singleton{
private static $data;
function __construct(){
if ($this::$data == null){
$this->makeSingleton();
}
echo "<br/>".$this::$data;
}
private function makeSingleton(){
$this::$data = rand(0, 100);
}
public function change($new_val){
$this::$data = $new_val;
}
public function printme(){
echo "<br/>".$this::$data;
}
}
$a = new Singleton();
$b = new Singleton();
$c = new Singleton();
$a->change(-2);
$a->printme();
$b->printme();
$d = new Singleton();
$d->printme();
