Req #42269 [Opn->Csd]: Abstract Classes - "prototyping" not fully allowed

Edit report at https://bugs.php.net/bug.php?id=42269&edit=1 ID: 42269 User updated by: kevin at metalaxe dot com Reported by: kevin at metalaxe dot com Summary: Abstract Classes - "prototyping" not fully allowed -Status: Open +Status: Closed Type: Feature/Change Request -Package: Feature/Change Request +Package: *General Issues Operating System: All PHP Version: 5.2.3 Block user comment: N Private report: N New Comment: I've learned the errors of my ways Previous Comments: ------------------------------------------------------------------------ [2007-08-11 01:08:05] kevin at metalaxe dot com Changing to proper version ------------------------------------------------------------------------ [2007-08-11 00:44:30] kevin at metalaxe dot com Description: ------------ I was working on an interface (abstract class) to implement for kernel subroutines (that will be singleton classes) in my program/framework and wanted to define things that needed to be implemented in applicable classes when I found that I couldn't do everything I needed, or feel I need, to do in order to prevent "hacking" in extending classes. I don't expect that these things will be implemented, but it is something to think about and i feel it would give PHP an edge over many other languages, if they are not already implemented in them (as some are). #1 Properties cannot be implemented as abstract Doing so returns "Fatal error: Properties cannot be declared abstract." Int he case of a singleton prototype, I'd want to be sure that a property of the name "instance" was created by the implementing class. #2 Abstract methods cannot be defined as private This is a 2 part issue in my opinion. First of all, why can't they be? If I define a method as abstract and private it means that I want the implementing class to define that method as private. In the case of this prototype, I want to ensure that the class in indeed a singleton and cannot be initiated except though the static method defined later. This brings me to part 2. #3 Defining abstract methods as private or protected allows for "weaker" visibility This makes defining a prototype class completely useless. If the user is allowed to ignore my preset visibility and do whatever they want, why would I ever use abstract to define classes? You don't implement an interface to "do what you want", you implement an interface to "do what it wants". Now, on the other hand, and if the prototype allows it (see below), it is perfectly acceptable to be allowed to extend an implementing class to add new behavior. This behavior might include overriding the visibility of a method set in a parent class and assigning it as a weaker alternative. #4 Abstract methods cannot use the final keyword As another aside in regards to defining abstract methods this should be perfectly valid as well if considering prototyping. If I prototype a method to be final, this means that I want the implementing class to implement this method as final(NOT that I want the abstract as final, as the error message seems to imply). Using the above guideline using a declaration like so: abstract private final function __construct(); ...should mean that the implementing class MUST define that method as so: private final function __construct(){} #5 And finally, static methods are not applicable to abstraction/prototyping This causes an E_STRICT error of "Strict Standards: Static function kernel_interface::init() should not be abstract". Again I ask, "Why shoudn't it be?" By defining a method like so: abstract public static function &init(); ..I am effectively telling the implementing class that it needs to define the method as: public static function &init(){} ...which is perfectly acceptable as I want to be sure that, in my case, a singleton class implements a public, static, method unto which it can be initiated. Anyway, sorry for the long report, but I figured it was better than opening 1 for each example I'd like to see. I'm perfectly happy waiting for this, but I'd really like to see most of these implemented. I hope that my example below is enough to deem considerable. Reproduce code: --------------- /** * Kernel Interface * * An interface class all kernel subroutines implement. * All classes implementing this interface are singletons! **/ abstract class kernel_interface { /** * Instance * Contains loaded this instance * * @var object * @access private **/ abstract private static $instance = NULL; /** * Core * Reference to kernel_core * * @var object * @access private **/ abstract private $core; /** * Construct * Load up the construct. Private for singleton. * * @param object Reference to kernel_core * @access private */ abstract private final function __construct( kernel_core &$core ); /** * INIT * Ensures that only one instance is created * * @param object Reference to kernel_core * @access private */ abstract public static final function &init( kernel_core &$core ); /** * Run * Returns the selected data based on type * * @param array Array of parameters passed to the __call overload in kernel_core * @return object Reference to requested call functionality * @access public */ abstract public final function &run( Array $params ); /** * Clone * Cloning is disabled for singleton * * @access public * @final **/ public final function __clone() { trigger_error('Clone is not allowed.', E_USER_ERROR); } }// end interface //begin implementing class final class kernel_input_handler extends kernel_interface { /** * Instance * Contains loaded this instance * * @var object * @access private **/ private static $instance = NULL; /** * Core * * @var object * @access private **/ private $core; /** * Construct * * @param object reference to kernel_core * @access private **/ private final function __construct( kernel_core &$core ) { $this->core =& $core; } /** * INIT * Ensures that only one instance of kernel is created * * @param array Loaded configuration values * @access private **/ public static final function &init( kernel_core &$core ) { if ( self::$instance === NULL ) { self::$instance = new self( $core ); } return self::$instance; } /** * Get * Inititates the selected input class and returns the "gotten" data * * @param string array to get input from * @access public * @final **/ public final function &run( Array $params ) { # Testing return $params; } } Expected result: ---------------- Explained in description :) Actual result: -------------- Explained above :) ------------------------------------------------------------------------ -- Edit this bug report at https://bugs.php.net/bug.php?id=42269&edit=1