<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>类-属性-访问控制-静态Static-类常量-类的自动加载-构造函数和析构函数</title>
</head>
<body>
<?php
date_default_timezone_set("Asia/Shanghai");
#类-属性-访问控制-静态Static-类常量-类的自动加载-构造函数和析构函数
#NOTE: 如果直接使用 var 声明属性,而没有用 public,protected 或 private 之一,PHP 5 会将其视为 public
#TIPS:方法内访问属性使用:$this->属性名;方法内访问静态属性和方法使用:self::属性名(或静态方法名)
function demo() {
class A {
public $name = 'xxl';
public static $age = '25';
function echoMessage() {
echo $this->name;
echo '<br>';
echo self::$age;
}
}
(new A())->echoMessage();
}
// demo();
/**
* 访问控制-属性声明
* tips:
* 1. 关键词 public:被定义为公有的类成员可以在任何地方被访问
* 2. 关键词 protected:被定义为受保护的类成员则可以被其自身以及其子类和父类访问
* 3. 关键词 private:被定义为私有的类成员则只能被其定义所在的类访问
* 4. final关键词:使用final的类不能被继承
* 5. 继承的子类重新定义的方法覆盖父类方法,覆盖方法的访问控制范围小于父类方法
*/
function demo2() {
class MyClass {
public $public = 'Public';
protected $protected = 'Protected';
private $private = 'Private';
function printHello () {
echo $this->public;
echo $this->protected;
echo $this->private;
}
}
$obj = new MyClass();
echo $obj->public;
// echo $obj->protected; //致命错误Fatal error: Cannot access protected property MyClass::$protected
// echo $obj->private; //致命错误Fatal error: Cannot access private property MyClass::$private
echo '<br><hr>';
class MyClass2 extends MyClass {
protected $protected = 'Protected2';
function printHello () {
echo $this->public; //Public
echo $this->protected; //Protected2
echo $this->private; //未定义
}
}
$obj2 = new MyClass2();
echo $obj2->public;
// echo $obj2->protected; //致命错误
echo $obj2->private; //Notice: 未定义private,因为属性是私有的,无法被继承
$obj2->printHello();
}
// demo2();
/**
* 访问控制-方法声明
* tips: 作用和属性声明相同
*/
function demo3() {
class MyClass {
// 声明一个公有的构造函数
public function __construct () {}
// 声明一个公有的方法
public function MyPublic () {
echo '公有的方法<br>';
}
// 声明一个受保护的方法
protected function MyProtected () {
echo '受保护的方法<br>';
}
// 声明一个私有的方法
private function MyPrivate () {
echo '私有的方法<br>';
}
// 默认为公有方法
function Foo () {
$this->MyPublic();
$this->MyProtected();
$this->MyPrivate();
}
}
$myclass = new MyClass();
$myclass->MyPublic();
// $myclass->MyProtected(); //致命错误Fatal error: Call to protected method MyClass::MyProtected()
// $myclass->MyPrivate(); //致命错误Fatal error: Call to private method MyClass::MyPrivate()
$myclass->Foo();
class MyClass2 extends Myclass {
function Foo2() {
$this->MyPublic();
$this->MyProtected();
$this->MyPrivate(); //致命错误Fatal error: Call to private method MyClass::MyPrivate()
}
}
$myclass2 = new MyClass2();
$myclass2->MyPublic();
$myclass2->Foo2();
class Bar {
public function testPublic () {
echo 'Foo:testPrivate<br>';
}
}
}
// demo3();
/**
* 访问同一个对象类型的私有成员
*/
function demo4() {
class Test {
private $foo;
public function __construct ($foo) {
$this->foo = $foo;
}
public function getfoo() {
echo $this->foo;
echo '<br>';
}
private function bar () {
echo 'Accessed the private method.';
}
public function baz (Test $other) {
$other->foo = 'hello';
var_dump($other->foo);
echo '<br>';
$other->bar();
}
}
$test = new Test('test');
$test2 = new Test('other');
$test->baz($test2);
echo '<br>';
$test->getfoo();
$test2->getfoo();
}
// demo4();
/**
* 静态属性和方法
* tips:
* 1. 由于静态方法不需要通过对象即可调用,所以伪变量 $this 在静态方法中不可用
* 2. 声明类属性或方法为静态,就可以不实例化类而直接访问。静态属性不能通过一个类已实例化的对象来访问(但静态方法可以)
*/
function demo5() {
class Foo {
public static $my_static = 'foo';
public function staticValue () {
return self::$my_static;
}
}
class Bar extends Foo {
public function fooStatic () {
return parent::$my_static;
}
}
echo Foo::$my_static.'<br>';
$foo = new Foo();
echo $foo->staticValue().'<br>';
// echo $foo->my_static; //错误Strict Standards: Accessing static property Foo::$my_static as non static
echo '<br><hr>';
echo $foo::$my_static.'<br>';
$classname = 'Foo';
echo $classname::$my_static.'<br>';
echo '<br><hr>';
echo Bar::$my_static.'<br>';
$bar = new Bar();
echo $bar->fooStatic().'<br>';
}
// demo5();
/**
* 类常量
*/
function demo6() {
class MyClass {
const AB = 'abcdef';
function showConstant () {
echo self::AB.'<br>';
}
}
$myclass = new MyClass();
$myclass->showConstant();
echo MyClass::AB.'<br>';
}
// demo6();
/**
* 类的自动加载
* 魔术函数__autoload
* tips: 可以使用spl_autoload_register()注册给定的函数作为 __autoload 的实现;或使用spl_autoload
*/
function demo7() {
function __autoload($class_name) {
echo '类名: '.$class_name.'<br>';
require_once 'test/'.$class_name.'.php';
}
$obj1 = new MyClass1();
}
// demo7();
/**
* 构造函数和析构函数
*/
function demo8() {
class MyDestructableClass {
function __construct () {
print "In constructor <br>" ;
$this -> name = "MyDestructableClass" ;
}
function echoMes() {
echo '测试信息<br>';
}
function __destruct () {
print "Destroying " . $this -> name . "\n" ;
}
}
$obj = new MyDestructableClass ();
$obj->echoMes();
}
demo8();
?>
</body>
</html>
PHP:类-属性-访问控制-静态Static-类常量-类的自动加载-构造函数和析构函数
最新推荐文章于 2024-02-26 11:49:26 发布