PHP-面向对象_技术笔记

慕函数7722910 2022-07-13

<?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();

0赞 · 0采集
chaulee926 2020-01-01

实现工厂模式：在定义多个功能类似的类，可以加一个工厂类，在这个工厂类里只返回实例化的后的类，然后切换底层的功能就只能修改工厂类了；
比如memcache和redis驱动，可以定义一个Cache类来作为工厂类来实现缓存切换；

截图
0赞 · 0采集
chaulee926 2020-01-01

要实现单例首先要将__construct和__clone方法私有化，然后定义个获取实例的静态方法，使用instanceof来判断实例化的对象是否属于当前对象，如果属于则直接返回，不属于则new一个;
单例模式的好处可以减少内存开销；

截图
0赞 · 0采集
chaulee926 2020-01-01

抽象类跟接口差不多，都可以定义空方法，但是接口里面定义的方法不能实现具体功能，只能定义空方法(不能写具体的代码)，而抽象类可以定义空方法，也可以实现方法的具体功能(可以写具体的代码);

截图
0赞 · 0采集
chaulee926 2020-01-01

面向对象编程其实也是面向接口编程，使用接口来设计功能会使代码松耦合，设计功能的时候尽量使用接口来设计功能。
接口是不能被实例化的；
接口之间可以继承；

截图
0赞 · 0采集
倡萌 2019-10-08

工厂模式：负责用来创建类的实例

截图
0赞 · 0采集
倡萌 2019-10-08

单例模式：确保一个类只有一个实例

截图
0赞 · 0采集
倡萌 2019-10-08

抽象类（abstract）：区别于接口 interface 在于，里面可以包含具体的方法

截图
0赞 · 0采集
倡萌 2019-10-08

接口 interface：定义空的方法，然后其他类来实现方法的具体操作
接口不能被直接实例化
接口可以继承
接口可以使用常量

截图
0赞 · 0采集
kwanzw 2019-08-07

单例模式例子

截图
0赞 · 0采集
pingwang 2019-06-02

2-9 接口类和抽象类以及设计模式

单例模式
public static function getInstance()
{
if(!(self::$_instance instanceof of self)){
self::$_insance = new self();
}
return self::$_instance;
}
判断 $_instance 是否为当前类的事例

截图
0赞 · 0采集
pingwang 2019-06-02

2-9 接口类和抽象类以及设计模式
abstract 、 interface 的区别
抽象类中可以有部分函数的具体实现，但接口不可以

截图
0赞 · 0采集
pingwang 2019-06-02

interface Ia
interface Ib
interface AB extends Ia, Ib - 继承
class Test implements AB - 实现

截图
0赞 · 0采集
碰磁王110 2019-05-13

<?php
class test1{
public static function __callStatic($model,$arga)
{
echo $model."<br />";
print_r($arga);
}
}
test1::go(1,'ok');

echo "<hr />";
class A{
public function go()
{
echo 'gogogogog....';
}
}
function test(A $a)
{
$a->go();
}
test(new A());

echo "<hr /> 单例模式：";
class Test{
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;
}
}
$test1 = Test::getInstance();
$test2 = Test::getInstance();
$test3 = Test::getInstance();
var_dump($test1);
var_dump($test2);
var_dump($test3);

echo "<hr /> 工厂模式：便于底层类的批量修改";
class Redis
{
public function set(){}
public function get(){}
}
class Cache
{
public static function factory()
{
return new Redis();
}
}
$Cache = Cache::factory();
var_dump($Cache->set());
echo "<hr />";
?>
final 不被继承的，可以放到类或者方法的前面。

全局空间的类，前面加上"\"。(use \Test1;)

__autoload 当未找到引入的类，则会自动实现实例化类名的路由。

spl_autoload_register(function($className){
require str_replace("\\","/",$className . '.php');
});
替代__autoload自动加载类的方法。

当为类里面的属性加上“static”关键字后，可以直接通过类名调用。

类的后期静态绑定：子类中有父类的同名函数，继承之后，若想调用子类的同名函数，则父类的方法加“static::who()”。

魔术方法：
__set();__get();
__isset();判断私有属性(private)是否存在。
__unset();删除私有属性。
__call();调用的方法不存在时，自动调用此方法。
__callStatic();当发现调用的静态方法不存在时，则自动调用此方法。
__invoke();将对象以函数方式调用。test('go...');
__toString();直接打印对象函数。echo(test);
__clone();将浅拷贝，变成深拷贝。
PHP中对象的赋值是浅拷贝。深拷贝用clone。

trait类，可以用use方法调用。

interface接口类，不实现方法。

abstract抽象类，既可以定义接口，又可以实现方法。

单例模式和工厂模式：
单例模式同一个类，不用被实例化多次，从而节省内存。

0赞 · 0采集
菜5 2019-04-10

谢谢老师

截图
0赞 · 0采集
慕斯3597358 2018-12-08

设计模式

截图
0赞 · 0采集
慕斯卡6376950 2018-11-17

类可以implements多个接口，接口可以extends一个接口

截图
0赞 · 0采集
taisen丶 2018-10-25

抽象类中定义的方法可以实现，也可以不实现。

1赞 · 0采集

慕粉1823464634 2018-07-10

单例模式能确保类只有一个实例

class Test{
    private static $_instance=null;
    private function __construct(){
    }
    private function __clone()
    {
    }
    public static function getIstance(){
        if(!(self::$_instance instanceof self)){
            self::$_instance =new self();
        }
        return self::$_instance;
    }
}

1赞 · 1采集

慕粉1823464634 2018-07-10

抽象类里面可以实现一个方法接口里面不可以

0赞 · 0采集
慕粉1823464634 2018-07-10

接口可以被继承但是不能被直接实例化

0赞 · 0采集
慕粉1823464634 2018-07-10

接口是类的模版类是对象的模版接口中定义的方法都是空方法不做任何实现

0赞 · 0采集
望断天涯路006 2018-03-06

单例模式和工厂模式

截图
0赞 · 0采集
我不是钟钟 2018-03-04

抽象类和普通类的区别，抽象类的空方法继承后必须重写实现，而普通类不用

截图
0赞 · 0采集
xieqc 2018-01-09

讲的不错，学习完毕。mark

截图
0赞 · 0采集
回首已是千年 2018-01-01

工厂模式 class redis { public function get(){ } public function set(){ } } class cache { public static function factory() { return new redis; } } //定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行这里cache即为子类

0赞 · 0采集
回首已是千年 2018-01-01

单例模式示例代码： class Test { private static $_instance //该静态变量用于存储该类 private function __construct() //该类不能被new { } private function __clone() //该类不能被克隆 { } public static function getInstance() { if(!(self::$_instance instanceof self)){ //instanceof属于该类的实例 self::$_instance = new self(); //如果不是就new 一个 } return self::$_instance //如果是就返回 } } Test::getInstance(); //调取该类

0赞 · 0采集
回首已是千年 2018-01-01

单例模式：每个类只能被实例化一次。因为每实例化就会占用内存空间，这样可以节省空间注意： 1、单例类只能有一个实例。 2、单例类必须自己创建自己的唯一实例。 3、单例类必须给所有其他对象提供这一实例。主要解决：一个全局使用的类频繁地创建与销毁。何时使用：当您想控制实例数目，节省系统资源的时候。工厂模式：意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。主要解决：主要解决接口选择的问题。何时使用：我们明确地计划不同条件下创建不同实例时。如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。关键代码：创建过程在其子类执行。

2赞 · 2采集
回首已是千年 2018-01-01

抽象类： PHP抽象类应用的定义： abstract class ClassName{ } 如果需要在接口中实现某方法而接口中是不能实现的，这时可以用到抽象类来实现。抽象类中可以具体实现某方法。接口只是定义了空方法。

0赞 · 0采集
回首已是千年 2018-01-01

PHP抽象类应用的定义： abstract class ClassName{ } PHP抽象类应用要点：　　1.定义一些方法，子类必须完全实现这个抽象中所有的方法　　2.不能从抽象类创建对象，它的意义在于被扩展　　3.抽象类通常具有抽象方法，方法中没有大括号

0赞 · 0采集

数据加载中...