【PHP】面向对象-继承相关知识

最新推荐文章于 2024-03-22 08:23:15 发布
最新推荐文章于 2024-03-22 08:23:15 发布
阅读量639 收藏 3
点赞数
分类专栏： PHP 文章标签： php android 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chuxinchangcun/article/details/132451017
版权

文章目录

关于继承

继承extends，是指子类通过继承可以访问父类的成员。

基本语法

class 子类 extends 父类{}

继承目标：继承本质是针对同类有包含关系的共性继承，即父类通常是包含子类，子类属于父类。所以在父类中通常定义的是子类共有的一些特性成员，这是开发者默认遵循的规则

有限继承

有限继承，指子类在继承父类的成员的时候，并非继承所有内容，而是继承并使用父类部分内容。

继承的内容：

PHP中继承是子类继承父类所有的公有成员、受保护成员和私有成员，不能继承父类的私有方法

  • 子类可以在内部访问父类的保护和公有方法，但是不能访问父类的私有方法，子类只能在外部访问父类的公有方法

  • 父类私有成员虽然被你继承下来了，但是你不能直接访问！

  • 访问父类私有成员：子类若想访问父类私有成员，那么前提是父类提供了能够访问私有成员的接口：即提供了公有或者受保护的方法给子类访问

//父类
class Human{
    const CALL = '人';
    public $name = 'human';
    protected $age = '100';
    private $money = '100';
    
    public function showName(){
        echo $this->name;
    }
    
    protected function showAge(){
        echo $this->age;
    }
    
    private function showMoney(){
        echo $this->money;
    }
}

//子类
class Man extends Human{} 
//实例化子类
$m = new Man();

//object(Man)#1 (3) { ["name"]=> string(5) "human" ["age":protected]=> string(3) "100" ["money":"Human":private]=> string(3) "100" }
var_dump($m);				//可以看到父类私有属性  ==>所有的属性(成员)都可以看到

$m->showName();				//允许直接访问：方法为公有允许类外访问

关于父类protected成员

protected关键字的产生本身就是纯用于继承的，表示允许被子类在子类内部访问的意思，而不允许子类在外部直接访问这个保护成员。

class Human{
    protected $age = '100';
    protected function showAge(){
        echo $this->age;
    }
}

//子类
class Man extends Human{
    //在子类内部增加公有访问访问继承自父类的受保护成员
    public function getProtected(){
        echo $this->age;				//访问父类受保护属性
        $this->showAge();				//访问父类受保护方法
    }
}

关于静态成员和类常量

静态成员和类常量也遵循继承规则，只是访问方式是由类进行访问

class Human{
    const NAME = '人';
    public static $count = 0;
    protected static $type = array('黑','黄','白');
    
    public static function getCount(){
        echo self::NAME;
        echo self::$count;
    }
    protected static function getType(){
        print_r(self::$type);
    }
}

class Man extends Human{
    //依然需要子类中访问受保护成员
    public static function getHuman(){
        Human::getType();
    }
}

echo Man::$count;	//允许直接访问
Man::getCount();	//访问父类静态方法
Man::getHuman();	//利用子类公有方法访问父类受保护成员
echo Man::NAME;  	//允许访问父类类常量

关于父类私有成员

子类若想访问父类私有成员，那么前提是父类提供了能够访问私有成员的接口：即提供了公有的方法给子类访问，否则子类不能直接访问父类的私有成员

class A
{
    private $name = "mango";
    public function GetName()
    {
        echo $this->name;
    }
}
class B extends A 
{}
$b->name;
$b->GetName();

关于构造方法和析构方法

构造方法和析构方法也可以被子类继承，此时需要注意子类对象实例化时对应的父类构造方法的参数

//父类
class Human{
    private $money;
    public function __construct($money){
        var_dump($this)
        $this->money = $money;
    }
    
    public function __destruct(){
        echo 'die';
    }
}

//子类继承
class Man extends Human{}

//子类实例化：自身是空类，没有指定构造方法
//$m = new Man();					//错误：缺少参数，因为会自动调用父类构造方法
$m = new Man(100);					//正确

重写-override

重写，即子类中定义了与父类重名的成员，子类可以重写父类任意类成员，通常重写是用来重写父类的方法，用于扩展或者更改某些业务逻辑。

1.子类继承父类，同时子类定义与父类同名的类成员

2.重写父类成员之后，子类只会直接访问子类的成员（覆盖）

注意：不管是公有和是受保护属性，一旦重写，父类的就会不存在，而私有属性不会被覆盖，因为子类本身也不能访问父类的私有属性

class A
{
    private $name = "mango";
    public $age = 20;
    protected $sex = 'man';
    public function show()
    {
        echo __CLASS__;
    }
}
class B extends A 
{
    private $name = "lemon";
    public $age = 21;
    protected $sex = 'boy';
    public function show()
    {
        echo __CLASS__;
    }
}
$b = new B();
var_dump($b);
/*
object(B)#1 (4) { 
    ["name":"B":private]=> string(5) "lemon" 
    ["age"]=> int(21) 
    ["sex":protected]=> string(3) "boy" 
    ["name":"A":private]=> string(5) "mango" 
}
*/

$b->show(); //B

重写的要求：

1：子类重写父类的方法 ，控制权不能高于父类，即子类可以比父类更开放 private > protected > public

  • 比如父类的控制权为protected，那么子类的控制权不能为private，只能为protected 或者public
//父类
class Human{
    protected function show(){
        echo __CLASS__,'<br/>';
    } 
}

//子类继承
class Man extends Human{
    //重写
    protected function show(){}				//正确
    public function show(){}				//允许
    private function show(){}				//错误：控制权比父类更严格
         
}

2：PHP中重写要求子类重写父类方法的时候，必须保证与父类同名方法参数一致

注意：在方法参数一致不单单要求数量一致，而且数据类型要求也必须相同，但形参名字可以不同；另外，在PHP7以前重写对于参数这块没有要求

//父类
class Human{
    protected function show(){
        echo __CLASS__,'<br/>';
    }
}

//子类继承
class Man extends Human{
    //重写
    public function show(){}
    public function show($a){}			//错误，与父类同名方法不一致
}

3：重写针对的是被继承的成员，父类私有方法不会被继承，因此不受要求2规定

//父类
class Human{
    private function show(){
        echo __CLASS__,'<br/>';
    }
}

//子类
class Man extends Human{
    private function show($name){	//不会报错，因为本质不存在重写（父类Human::show没有被继承）
        echo $name,'<br/>';
    }
}

4.重写是指子类拥有特殊的情况，一般是需要在父类的基础上进行扩展，此时如果想要继续保证父类被重写的方法继续执行（默认永远只访问子类重写的新方法），需要在子类重写方法的时候使用parent关键字

  • parent::父类方法()

注意：parent专门用来访问父类被重写的方法，至于是不是在同名的方法里面使用无所谓！parent不能访问父类的普通成员，可以访问静态成员、静态方法、类常量和普通方法

//父类
class Human{
    protected function show(){
        echo __CLASS__,'<br/>';
    }
}

//子类继承
class Man extends Human{
    //重写
    public function show(){
        //强制调用父类被重写方法
        parent::show();
        
        //扩展业务逻辑
        echo __CLASS__,'<br/>';
    }
}

继承特点

1.PHP中继承只能单继承：即子类只有一个父类（有些语言支持多继承）

2.PHP若想继承多个类，可以使用链式继承

3.PHP中继承只有私有方法不能被继承，其它的都可以被继承，包括私有属性，但是该私有属性，子类在类内和类外都不能访问，只能通过父类提供的公有方法进行访问

  • 而对于父类的保护成员，子类可以在类内访问，但是不能在类外进行访问
class Man{}
class Woman extends Man{}
class Ladyboy extends Woman{}	//Ladyboy包含了Man和Woman类中所有可继承的成员

4.PHP允许子类继承父类的构造方法和析构方法

静态延迟绑定

1静态延迟绑定对比的是静态绑定self ，使用static关键字代替self进行类成员访问，

2.静态延迟绑定一定是通过继承后的子类来进行访问才有效果

3.静态延迟绑定是指通过static关键字进行类静态成员的访问，是指在被访问时才决定到底使用哪个类，也就是根据调用类的不同而选择不同的表现

  • 使用self的时候是访问该类静态成员，与调用类无关
//父类
class Human{
    public static $name = 'Human';
    public static function showName(){
        //静态绑定
        echo self::$name,'<br/>';
    }
}
//子类
class Man extends Human{
    //重写父类静态属性
    public static $name = 'Man';	//静态属性因为存储在类内部，因此不会覆盖
}

//子类访问
Man::showName();					//输出Human
Human::showName();					//输出Human
  • 如果使用static，此时会根据调用类的不同而选择不同的表现
//父类
class Human{
    public static $name = 'Human';
    public static function showName(){
        //静态绑定
        echo static::$name,'<br/>';
    }
}
//子类
class Man extends Human{
    //重写父类静态属性
    public static $name = 'Man';	//静态属性因为存储在类内部，因此不会覆盖
}

//子类访问
Man::showName();					//输出Mang
Human::showName();					//输出Human

最终类

1.最终类：使用final关键字修饰类名，表示此类不可以被继承

  • final修饰类表示不希望类再出现子类，可以很好保护类的内部结构不被暴露
//最终类
final class Man{}

class Man18 extends Man{}		//致命错误：无法从final类继承

2.final关键字不止修饰类表示类不可被继承，还能修饰方法，表示方法不能被重写

  • final修饰方法表示不希望方法被修改，可以在一个更高的维度来保证同类事务的共同表现
//父类
class Human{
    public function show(){}		//普通方法
    public final function walk(){}	//最终方法
}
//子类
class Man extends Human{
    //重写
    public function show(){}		//没问题
    public function walk(){}		//致命错误：不能重写父类中的最终方法
}

抽象类

1.抽象类：使用abstract关键字修饰的类，表示该类只能被继承，不能被实例化

//抽象类
abstract class Human{}
$h = new Human();				//致命错误，抽象类不能被实例化
class Man extends Human{}		//抽象类只能被继承

2.abstract关键字还可以用来修饰方法（抽象方法），抽象方法所在的类必须是抽象类，抽象方法不能有方法体

//抽象方法抽象类
abstract class Human{
    //定义抽象方法：没有方法体
    abstract public function eat();
    public function show(){}			//普通方法有方法体
}

3.抽象方法因为要被子类继承实现，所以不能使用private修饰（私有方法不会被继承）

//抽象类
abstract class Human{
    //抽象方法
    abstract private function eat();		//错误：抽象方法不能私有化
}

4.子类继承抽象类后：有抽象方法的抽象类被继承时子类要么自身是抽象类，要么实现所有抽象方法

  • 方法1：子类也声明为抽象类，这样就不用实现父类的抽象方法了，但是此时子类就无法实例化出对象，只能被其他类继承了
  • 方法2：子类实现抽象方法（所有抽象方法）
//抽象方法抽象类(父类)
abstract class Human{
    //定义抽象方法：没有方法体
    abstract public function eat();
    public function show(){}			//普通方法有方法体
}

//子类1：抽象类继承抽象类
abstract class Man extends Human{}		//正常继承


//子类2：子类实现父类所有抽象方法
class Boy extends Man{
    //实现从祖父类继承的eat抽象方法
    public function eat(){
        echo 'eat';
    }
}

5.抽象类的目的是用来规范子类（通常必配抽象方法）

接口Interface

1.接口：使用interface关键字定义，与类类似，专门用来规范一些共性类必须实现的方法

2.接口不是类，不可以被实例化

3.接口实现：接口是用来规范类必须完成的事情，所以接口只能被类实现：implements

  • 类实现接口的时候，必须实现接口中所有的抽象方法（或者抽象类实现）

4.接口成员：接口中只能定义公有抽象方法和接口常量，不能有其它属性

  • 在接口当中，方法默认就是自带abstract关键字
interface Human{
    //接口常量
    const NAME = '人';
    //接口抽象方法
    public function eat(); 
    
    //错误示例  
    public function go(){}				//错误：接口中的方法必须为抽象
    public $age;					   //错误：接口中不能有属性
    public static $count = 0;			//错误：接口中不能有静态属性（成员属性）
    protected function walk();			//错误：接口方法必须为公有抽象方法
}
class Man implements Human{}
new Human();				//致命错误，接口不能被实例化

5.接口成员方法必须被子类实现或者该类为抽象类，接口常量可以直接在实现类中方法

interface Human{
   //接口常量
    const NAME = '人';
    //接口抽象方法
    public function eat(); 
}

//方法1：实现接口
class Man implements Human{
    //必须实现接口所有抽象方法
    public function eat(){
        echo self::NAME;				//可以访问接口的 常量
    }
}
echo Man::NMAE; 	//没问题
//方法2：抽象类实现接口
abstract class Ladyboy implements Human{}		//正常实现,因为抽象类可以有抽象方法

6.实现接口的类成员，不允许重写接口中的常量，不允许增加接口方法的控制权限

class Woman implements Human{
    //重写接口常量
    const NAME = '女人';			  //错误：不允许重写接口常量
    
    //强化接口方法控制
    private function eat(){}		//错误：接口方法不允许使用其他访问修饰限定符，必须使用public
}

7.接口可以继承接口：extends，而且接口可以多继承接口

  • 此时如果有类实现Ape的方法：那么必须实现Ape，Huma，Animal当中的抽象接口
interface Human{
    public function walk();
}

interface Animal{
    public function eat();
}
//单继承
interface Man extends Human{}
//多继承
interface Ape extends Human,Animal{}

8.接口是在更大型的项目中，为了保证底层的实现而设定的规范，通常是抽象类实现接口，增加必要成员，然后让实际业务类去继承抽象类

trait代码复用

1.trait 是为类似 PHP 的单继承语言而准备的一种代码复用机制，trait是一种类似class的关键字

2.trait内部可以拥有一个类能拥有成员属性（包含静态），成员方法（包含静态），但不能有类常量

3.trait是用来实现代码的复用的，不可以被实例化也不可以被继承（因为trait不是类）

4.trait是用来将公共代码提供给其他类使用的，而类要使用trait的前提是加载对应的trait

trait Eat{
    public function show(){
        echo 'eat';
    }
}

//类中加载trait
class Human{
    //加载：使用use关键字
    use Eat;				//use就表示将trait Eat中的所有东西拿到了当前类Human中
}

//使用trait中的内容
$h = new Human();
$h->show();					//eat：Human类自己没有show方法，但是因为使用了trait Eat，所以可用

5.一个类可以使用多个traits，但是如果同时引入的多个trait中有同名方法，那么会产生冲突：解决冲突的方法是使用insteadof代替处理以及对被替代方法使用别名

冲突代码

trait t1{
    public function eat(){
        echo 't1,eat';
    }
}
trait t2{
    public function eat(){
        echo 't2,eat';
    }
}

class Human{
    use t1,t2;				//错误：eat()方法冲突
}

解决方法1：明确替代

//解决方案1：明确替代
class Person{
    use t1,t2{					//花括号
        t2::eat insteadof t1;	 //t2的eat代替t1的eat
    }
}
$p = new Person();
$p->eat();						//t2,eat；
//但此时就没办法让Person对象访问t1的eat方法了

解决方法2：先替换后别名

//解决方案2：先替换后别名
//一个替代另一个，然后另外一个取别名
class Animal{
    use t1,t2{  
        t1::eat insteadof t2;	//明确使用t1中的eat方法
        t2::eat as eat2;		//t2中的eat方法改名叫eat2
    }
}
$a = new Animal();
$a->eat();						//t1,eat
$a->eat2();						//t2,eat

6.同名覆盖问题：如果类中有与引入的trait同名成员，会有不同处理

  • 成员变量：不允许重名，即类中不允许定义与trait中同名的成员变量（静态变量也一样）
  • 方法：类中的方法覆盖引入的trait中的方法
trait Eat{
    public $food = '米饭';
    public function show(){
        echo $this->food;
    }
}

class Human{
    use Eat;
    
    //定义同名属性
    //public $food = '面条';		//错误
    
    //定义方法
    public function show(){
        echo 'show';
    }
}

$h = new Human();
$h->show();						//show：类覆盖掉trait

7.继承覆盖问题：如果类中在使用trait的同时，也是继承自父类，而trait中与父类中有同名方法，那么trait中将覆盖父类同名方法；如果要访问父类方法，可以在trait同名方法中使用parent关键字访问父类同名方法

  • 优先级：类自己 > trait > 基类
trait Eat{
    public function eat(){
        //如果想访问父类的eat方法: 		 parent::eat();
        echo 'Eat::eat';
    }
}
class Human{
    public function eat(){
        echo 'Human::eat';
    }
}
//子类继承父类同时使用trait
class Man extends Human{
    use Eat;
}

$m = new Man();
$m->eat(); //此时输出的是Eat::eat

8.允许类在使用trait时更改里面的方法的访问控制权：在as之后，使用目标访问修饰限定符

trait Eat{
    private function show(){
        echo 'eat';
    }
}
class Human{
    use Eat{
        //注意：as是用来设定别名的，虽然没有同名show，但是系统认为show已经存在，所以必须别名
        //所以:  show as public show;//err
        show as public  eshow;				
    }
}
$h = new Human();
$h->eshow();								//eat

上述show方法要改变权限，是把他变成一个新的方法，从而改变权限，原来的方法是不会被改变的

9.trait中可以使用抽象方法，用来规范使用类必须实现对应抽象方法：使用类要么为抽象类，要么就必须实现抽象方法

trait Eat{
    public function eat();		//抽象方法
}
abstract class Human{			  
    use Eat;					//抽象类：可以不实现抽象方法
}

class Animal{
    use Eat;
    public function eat(){		//具体类：必须实现抽象方法
        echo 'Animal::eat';	
    }		
}

对象遍历-foreach

遍历对象，其实就是指将对象中的所有属性（公有属性）以键值对的形式取出并进行访问

1.foreach可以对对象像数组一样遍历

2.foreach遍历对象遍历的是对象内部的所有公有属性（在类外部进行对象遍历），如果是在类内部，此时可以访问对象的所有属性

header('Content-type:text/html;charset=utf-8');
class Test
{
    public $name = 'Mango';
    public $age = 21;
    protected $sex = 'male';
    private $money = '∞';
    //类内遍历
    public function PrintObject()
    {
        foreach($this as $key => $val)
            echo $key . " ==> " . $val,'<br/>'; 
    }
}
$m = new Test();
$m->PrintObject();

echo '<hr/>';
foreach($m as $key => $val)
    echo $key . " ==> " . $val,'<br/>'; 

/*输出：
name ==> Mango
age ==> 21
sex ==> male
money ==> ∞
name ==> Mango
age ==> 21
芒果再努力
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
php面向对象重点知识分享
01-02
1、$this是什么 当前类实例化的对象 2、访问对象中的成员 对象->成员 3、构造方法 通常用来初始化对象的属性，不用把属性写死，不同的对象就有了不同的属性 4、get、set的用法 通常将属性设为protected，利用getXxx和setXxx方法来设置和获取属性的值，避免外部随意的更改，同时还可以对对象进行过滤。 5、类的封装 public方法可以在类外访问，相当于提供给外部的接口 private方法只能在类内（即类的大括号内），外部不能直接访问，只能通过其他public方法来调用，就像电脑的开关，按电源键就可以开 机。 protected,同private，不过可以在其他的类中继承
浅谈PHP面向对象编程（五、继承）
dice7578的博客
10-18 297
5.0 继承 5.1 继承的概念 在现实生活中，继承一般指的是子女继承父辈的财产。在程序中，继承描述的是事物之间的所属关系，通过继承可以使许多事物之间形成一种关系体系 。 例如猫和狗都属于动物，程序中便可以描述为猫和狗继承自动物。同理，波斯猫和田园猫继承自猫，而阿拉斯加和哈士奇继承自犬，这些动物之间会形成一个继承体系， 具体下图所示。 在PHP中，...
PHP如何实现类的继承？
最新发布
长风破浪会有时的博客
03-22 136
首先，我们来想象一下，类的继承就像是一个家族的传承。在这个家族里，有爷爷、爸爸和你。爷爷有一些特点，比如他很和蔼、喜欢讲故事。爸爸从爷爷那里继承了一些特点，也就是他也变得很和蔼，喜欢讲故事。然后，你从爸爸那里又继承了这些特点。在PHP中，类就像是我们的家族成员，而类的继承就像是家族特点的传承。类的对象也可以调用这个方法。类，就像爸爸继承了爷爷的特点，所以爸爸也会讲故事。类，你也继承了爸爸（和爷爷）的特点，所以你也会讲故事。类中定义的，但是因为继承的关系，类就像是爷爷，它有一个。方法，表示爷爷会讲故事。
php面向对象——继承
沉梦昂志
04-18 318
继承概念 以一个类为父类，另一个类作为其子类，子类在继承了父类属性/方法的基础上还可以进一步增添或修改，提高类代码复用性。 继承写法 php使用关键字 extends 来继承一个类，php不支持多继承 例如：class Stu extends Human,Dog,Pig {} 错的！ /*思考： 1.继承了那些东西？ 2.子类可以做什么扩充？ 3.构造函数如何继承？ 4.私有属性方法如何继承？...
PHP8的继承和多态-PHP8知识详解
站长在线在CSDN
09-25 299
父类拥有其子类的公共属性和方法。子类除了拥有父类具有的公共属性和方法外，还拥有自己独有的属性和方法。如果子类中有自己的构造方法，则PHP会先调用子类中的方法。如果子类中没有自己的构造方法，则 PHP会调用父类中的构造方法，这就是继承。从结果中可以看出，本案例创建了一个Language父类，子类通过关键字extends继承了Language父类中的。多态性是指同一操作作用于不同类的实例，将产生不同的执行结果，即不同类的对象收到相同的消息时，得到不同的结果。好了，到此为止，PHP8的继承和多态就讲解完毕了。
掌握PHP中的继承神器：深度解读parent关键字的高级应用技巧
u011715638的博客
02-26 450
它不仅是PHP继承中的神器，更是实现代码高效复用、提高开发效率的利器。关键字则是继承中的神器，它不仅能够让子类轻松调用父类的方法和属性，还能在子类中实现更高级的功能。这在子类需要使用父类的属性时非常有用，可以避免重复定义属性，实现代码的高效复用。编程中，继承是一种强大的工具，它允许我们在已有类的基础上创建新的类，并扩展或修改其功能。，子类可以执行父类的初始化操作，并在此基础上添加自己的初始化逻辑，实现更灵活的对象初始化。的方式，子类可以轻松调用父类的方法，并在此基础上实现功能的扩展。除了调用父类方法外，
php-＞继承
qq_62779007的博客
05-08 798
<?php //继承 /*类可以从其他类中扩展出来，扩展或者派生出来的类用其基类（分类）的所有变量和函数，并包含所有派生类(子类)中定义新功能，这称为继承。继承是面向对象的最重要的特点之一，可以实现对类的复用*/ //PHP 是单继承的，一个扩充类只能继承一个基类，但一个父类却可以被多个子类所继承。 //子类不能继承父类的私有属性和私有方法。在 PHP5之后的版本中，类的方法可以被继承，类的构造函数也能被继承。 //当子类被实例化时，PHP 会先在子类中查找构造方法。如果子类有自己的构造方法，P.
php继承（extends）
杰儿__er 的博客
06-25 820
php继承（extends）
php 多继承的几种常见实现方法示例
lxw1844912514的博客
10-11 524
什么是多继承？在面向对象编程中，继承是一种常见的方式，可以通过继承基类的属性和方法来扩展自己的类。而多继承则是指一个子类同时继承多个父类，以获得更多的属性和方法。在PHP中，单继承是一种非常常见的面向对象编程方式，而多继承则需要通过一些技巧来实现。下面我们来看看几种常见的多继承实现方法。多继承实现方法示例一、TraitTrait是PHP 5.4引入的一种新的语言结构，它可以通过多继承来解决代码复用...
PHP类的封装与继承浅谈
xiaoweids的博客
06-01 142
这三个修饰符从作用范围上来讲应该像这样从大到小排序：public→protected→private之所以说是在作用范围上，是因为类把一些属性和方法进行了封装，这个封装就决定了数据的“可见性”，这样我们在类的外面不能够随意修改所定义的属性和方法而只能够进行调用，这就是封装的好处，同时也提高了安全性。把成员方法和成员属性封装到类中，隐藏属性和方法实现的细节，通过public、protected、private等限定类成员的访问权限，数据被保护在内部，只通过被授权的成员方法才可以操作，尽可能的对成员进行封装。
PHP进阶——面向对象：
lilcur的博客
12-03 181
PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶PHP进阶
PHP面向对象继承用法详解(优化与减少代码重复)共5页.p
10-30
PHP面向对象继承用法详解(优化与减少代码重复)共5页.pdf.zip
测量程序编制 - python A6面向对象-类的多继承.pptx
05-10
面向对象——类的多继承;大部分面向对象的编程语言，都只支持单继承，即子类有且只能有一个父类。而 Python 却支持多继承（C++也支持多继承）。 和单继承相比，多继承容易让代码逻辑复杂、思路混乱，后来的?Java、C#...
PHP入门教程之面向对象的特性分析(继承,多态,接口,抽象
10-30
PHP入门教程之面向对象的特性分析(继承,多态,接口,抽象类,抽象方法等)共5页.pdf.zip
PHP 高级课程笔记 面向对象
10-29
第一节课，讲的是面向对象的基本知识，介绍了类的封装，类的继承，对象，类的定义和使用，类的结构，成员方法，成员变量与属性等零碎知识，这里只是把几个例子的源代码贴出来，仅供参考。
php中的继承和接口
jkzyx123的博客
01-09 661
php中的继承和接口
PHP中的继承和多态的关系是怎样的？
周祥平程序专栏
12-18 385
子类可以使用父类的属性和方法，并可以扩展或重写这些方法，以适应子类的特定需求。多态是OOP中的一个概念，允许不同的子类对象对相同的方法进行不同的实现。这意味着，尽管调用相同的方法名称，但实际执行的代码可能因对象的类型而异。继承（inheritance）和多态（polymorphism）是面向对象编程（OOP）的两个重要概念，它们在PHP中有密切关系，通常一起使用以提高代码的可扩展性和重用性。例如，您可以创建一个接口，并要求各个子类实现该接口的方法，然后使用多态性来调用这些方法，而无需关心具体的子类。
Php面向对象 – 继承和重写
Y_23k_bug的专栏
08-19 2168
Php面向对象 – 继承和重写     继承： php中，通过在类上，使用特殊的操作达到目的。 通过在定义类时，利用extends来指明当前类对象继承那个类的对象。   例子：   class C {        public  $p_c =  “value c”; }     class D extends C {        public  $p_d =
PHP语言之面向对象编程
m0_69120706的博客
04-25 2292
第一关：类的定义与对象创建 <?php class Student{ /**********Begin**********/ public $name; public $sex; public function setName($name){ $this->name=$name; } public function setGender($sex){ $this->sex=$sex; } public function sayHello(){ echo '大家好，我..
php面向对象三大特征
12-05
PHP面向对象的三大特征是继承、封装和多态。 1. 继承 继承是指一个类可以继承另一个类的属性和方法。在PHP中，使用extends关键字来实现继承。例如，下面的代码演示了如何让子类Student继承父类Person： ```php ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

芒果再努力

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值