-
结论： （1）、静态属性不需要实例化即可调用。因为静态属性存放的位置是在类里，调用方法为"类名::属性名"； （2）、静态方法不需要实例化即可调用。同上 （3）、静态方法不能调用非静态属性。因为非静态属性需要实例化后，存放在对象里； （4）、静态方法可以调用非静态方法，使用 self 关键词。php里，一个方法被self:: 后，它就自动转变为静态方法；查看全部
-
#PHP 类的继承 （父类，子类） 1.子类 可调用父类中的函数 2.子类 可覆盖父类中的函数 3.当子类没有构造方法时会自动调用父类 当子类自己有构造方法时则会调用自己的构造方法 子类若想在自己的构造方法中调用父类的构造方法 可用函数：parent：：__construct（）； 4.final在父类中加到class前，指子类不能继承父类 加到方法前，指子类不能继承父类的方法 #review protected 属性可被子类和父类看到和调用； private 属性只可被自己看到和调用；查看全部
-
final class Dad //Dad不被继承查看全部
-
使用as重命名导入类防止在使用use导入不同命名空间相同类时的冲突。查看全部
-
__call查看全部
-
<?php
use PhpOffice\PhpSpreadsheet\Calculation\Engineering\Compare;
/**
* 访问控制
* public 公有
* private 私有 只能在类内部使用
* protected
* 类的属性和方法
* this 类的一个实例
* 类常量
* ----继承----
* 当父类的方法是私有的private的时候，子类是不能调用的，内部是可以访问的
* 当父类的方法是受保护的protected的时候，子类是可以访问的
* 当子类的方法与父类的方法相同的时候， 子类覆盖父类方法
* 当子类没有构造方法时， 直接调用父类的构造方法
* 当子类和父类都有构造方法时， 子类调用其本身的构造方法，当想调用父类的构造方法时使用：parent::construct();
* ---final 关键字---
* final class Dad {} 类加上final 关键字后， 类不能被继承
* final function Name(){} 父类的方法加上final关键字后，该方法在子类时不能被重写的
* --- 命名空间---
* namespace venter\session
* namespace test
* ---define----
* define 定义常量是全局的
* --- const 定义常量----
* ---自动加载类 autoload 用的少 基本都在使用 spl_autoload_register()----
* ---static 关键字---
* 当属性和方法被定义为static的时候， 这个属性和方法就属于类的属性和方法， 可以直接调用， 不需要实例化
* ----对象复制---
* 在php中对象的拷贝是浅拷贝， 改变地址
*
* --- 接口---
* 接口是类的模板，类是对象的模板
* interface Person{
* }
*
**/
class Computer{
//属性
public $cpu=5000;
public $mainboard ='huashuo';
private $ht="512";
const ONE =1;
const TWO= self::ONE+1;
const THREE = self::TWO+1;
//构造方法 实例化的时候调用
public function __construct()
{
}
function __autoload($name){
require $name.".php";
}
//方法
public function game($gamename){
if($this->hdSize<1024){
echo '内存太小';
return false;
}
return true;
}
public function job($jobName='write code'){
$this->game("ddd");
}
public function hdSize(){
$this->ht;
}
//析构方法
public function __destruct()
{
}
}
// var_dump(Computer::THREE);
// $computer = new Computer();
// $computer->job();
class Person{
public static $hand ="手";
public static $foot = "脚";
static function getCount(){
return self::$foot;
}
}
echo Person::getCount();
class A{
public static function who(){
echo "A类的方法";
}
public static function test(){
//self::who() ; //父类本身的who方法
static::who(); // static 自动判断，是类A还是类B， 后期绑定
}
}
class B extends A{
public static function who(){
echo "B类的方法";
}
}
echo B::test(); // 此时输出 “B类的方法”
class Test{
private $abc="";
public $testi;
public function __set($var,$val){
$this->var=$val;
}
public function __get($var){
return $this->var;
}
//调用的方法不存在时， 不会报错 两个参数， 一个方法名， 一个参数名
public function __call($func,$var){
var_dump($var) ;
}
//静态方法未定时，调用不会报错 $test::goes("r","d","4");
public static function __callStatic($name, $arguments)
{
var_dump($arguments);
}
public function __toString(){
return $this->test;
}
}
$test = new Test();
$test->abc ='abcsss';
$test->go("q","d","dd"); //已数组的方式传参数 go方法没有定义，不会报错
$test::goes("r","d","4"); // 该方法未定义直接调用， 不会报错，
echo $test; //echo 输出对象不会报错， 因为定义了 __toString()魔术方法
var_dump($test->abc);
//接口-----------------------------------------------------------
interface Persons{
public function eat();
public function sleep();
}
class Woman implements Persons{
public function eat(){
echo "eat fruit";
}
public function sleep(){
echo 'sleep early';
}
}
class Man implements Persons{
public function eat(){
echo "eat fruit less";
}
public function sleep(){
echo 'stay up';
}
}
class L {
public static function factory(Persons $user){
return $user;
}
}
$result = L::factory(new Man());
$result->eat();
$result->sleep();
//接口 继承--------------------------------------------------------------------------
interface ai{
const abc="hhhh";
public function a();
}
interface bi{
public function b();
}
interface ab extends ai,bi{
}
class Test4 implements ab{
public function a(){
echo "aaaaaaaaa";
}
public function b(){
echo "bbbbbbb";
}
}
$dd = new Test4();
$dd->a();
$dd->b();
echo (ai::abc);
// 抽象类abstract、
abstract class ABC {
public function holiday(){
echo "wait";
}
public function sleep(){
}
public function eat(){
}
}
class ABB extends ABC{
public function sleep(){
echo "Yes";
}
public function eat(){
$this->holiday();
echo "No";
}
}
$aaa = new ABB();
$aaa->eat();
$aaa->sleep();
//------单例模式和工厂模式----------
//单例模式确保类只能有一个实例 节省空间
class TestAB{
private static $_instance =null;
private function __construct()
{
}
private function __clone(){
}
public static function getInstance(){
if(!(self::$_instance instanceof self)){
self::$_instance =new self();
}
return self::$_instance;
}
}
$nn = TestAB::getInstance();//实例化两次，但是只开辟一次空间 两个变量值相同
$nn2 = TestAB::getInstance();
print_r($nn) ;
print_r($nn2) ;
//------- 工厂模式
//
class Memcache{
public function set(){
}
public function get(){
}
public function delete(){
}
}
class Cache{
public static function factory(){
// 文档中多数运用Memcache类时， 假如因为当前需要，改为redis ，需要使用工厂模式
return new Memcache();
}
}
//直接把Memcache 替换为redis 即可， 其他代码部分不需要更改
$cache = cache::factory();
$cache->set();
查看全部 -
类型约束有int,string,array,float,bool等。但类也可以作为类型约束的类型之一，如图test(A $a)指的是$a必须是类A的对象，否则会报错。
查看全部 -
浅拷贝：对象赋值$b=$a，2个对象指向同一块内存地址，值发生改变会互相影响。浅拷贝比较省内存。
深拷贝:用clone关键字，会产生一块新的内存存储对象。clone后相当于有两个值相同的不同的对象。若clone的原对象里有对象属性如$a->obj，由于对象复制默认是浅拷贝，则要用到__clone魔术方法定义对象属性为深拷贝。这样$a->obj->sex才不受$b->obj->sex影响。
查看全部 -
self::who()和static::who()的区别在于self指的本类，即父类A，而static会根据代码实际情况判断指的是B类。
查看全部 -
static关键字
当属性和方法加上static关键字后，属性和方法就是类的，可以直接通过类名进行调用，无需实例化。么 当给一个属性加上static关键字，那么这个属性变成了类属性，不需要实例化类（获得对象）就可以直接用类名进行调用。如Person::$foot;方法同理如Person::work();
查看全部 -
命名空间+类名 = 类文件路径.
用spl_autoload_register()替换字符串后自动加载类文件
查看全部 -
命名空间和全局空间
1. 在全局空间中引用命名空间的类，用use关键字引入命名空间的类，as起别名。若引入函数则为use function venter\session\iLikeImooc;引入常量则为use const venter\IMOOC;
2.在命名空间中引用全局空间的类，若为namespace venter,即命名空间为venter,如new Test();类默认为venter\Test();找不到会报错，在类前加反斜杠new \Test();则为找到全局空间的Test类。函数和常量会先在命名空间中找，找不到会去全局找。
查看全部 -
外部想要对私有属性进行读取和修改。
<?php class Test { private $abc = ''; public function setAbc($val) //修改 { $this->abc = $val; } public function getAbc() //读取 { return $this->abc; } } $test = new Test(); $test = setAbc('hahaha'); //hahaha赋给参数$val var_dump($test->getAbc()); //打印出：string(6)"hahaha"若有多个私有属性要被外部访问，上述就不行了，所以有了两个魔术方法：__set 和 __get 。如：
<?php class Test { private $abc = ''; private $cba = ''; public function __set($var,$val) //修改。 __set(属性名，属性值) { $this->$var = $val; } public function __get($var) //读取。 __get(属性名) { return $this->$var; } } $test = new Test(); $test->abc = 'hahaha'; //当给私有属性赋值时，会默认自动地调用__set方法，如果类里没有__set方法，就会报错 var_dump($test->abc); //打印出：string(6)"hahaha"魔术方法 __isset 用于检测私有属性是否存在。
<?php class Test { private $abc = 'abc'; public function __isset($var) { return isset($this->$var)?true:false; } } $test = new Test(); var_dump(isset($test->abc)); //打印出：bool(true)魔术方法__unset 删除
<?php class Test { private $abc = 'aaa'; public function __unset($var) { unset($this->$var); } } $test = new Test(); unset($test->abc);为避免要调用的方法不存在，用魔术方法 __call 当被调用的方法不存在时，__call 会自动被调用。如：
<?php class Test { public function __call($func,$arguments) //__call(方法名，参数） { echo($func . "<br/>"); print_r($arguments); } } $test = new Test(); $test->go(1,'ok'); //结果为：go // Array( [0] =>1 [1] => ok )当静态方法不存在时，魔术方法__callStatic 会被自动调用。如：
<?php class Test { public static function __callStatic($method,$arg) //要加static关键字 __callStatic(方法名，参数) { echo($method . "<br/>"); print_r($arg); } } Test::go(1,'ok'); //结果为：go // Array( [0] =>1 [1] => ok )当对象以函数的方式被调用时，魔术方法__invoke会自动被调用。
<?php class Test { public function __invoke($arg) { var_dump($arg); } } $test = new Test(); $test('go....'); //这就是对象以函数的方式被调用 结果为：string(6)"go...."当对象被打印时，魔术方法__toString() 会自动被调用。
<?php class Test { public function __toString() { return "hello....."; } } $test = new Test(); echo($test); //结果为：hello......查看全部 -
<?php class A { public static function who() { echo "AAA"; } public static function test() { static::who(); //之后的结果为BBB，若用self::who()，则结果为AAA } //因为子类B调用父类的test方法，又调用who方法，子类父类都有who方法，用static是调用子类的who方法，用self是调用父类(也就是self所在类的)who方法 } //子类 class B extends A { public static function who() { echo "BBB"; } } B::test(); //因为这里是B，所以父类A和子类B都有who方法我们也要调用子类B的who方法，查看全部
举报