面向对象的特性

最新推荐文章于 2022-10-16 19:55:43 发布
最新推荐文章于 2022-10-16 19:55:43 发布
阅读量96 收藏
点赞数
分类专栏： PHP笔记 文章标签： 面向对象
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36432666/article/details/79806688
版权

面向对象三大特性：封装、继承、多态。

OOP封装

隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别：将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据的源代码进行有机的结合，形成“类”，其中数据和函数都是类的成员。

成员字段的作用域：

1、public 公共的（类外可以访问）
2、private 私有的（类内可以访问）
3、protected 受保护的（类内和子类可以访问，类外不可以访问）

创建私有字段，类外就无法访问了：

<?php
    class Computer{

        private $_name='联想';
    }

?>

通过一个公共方法作为入口，访问私有成员字段，必须使用$this关键字。

<?php
    class Computer{

        private $_name='联想';
        //采用一个公共对外的方法来访问私有字段
        //因为私有字段只能类内访问，而对外的公共方法是类内的。
        //而且公共方法又是公共的，所以类外又可访问。
        public function _run(){

            //成员字段在类内调用的时候必须是：类->字段，而$_name只是一个普通变量而已。
            //成员字段在类外调用的方法是：对象->字段，但类内就必须使用Computer->_name
            //在本类中，可以用$this来代替Computer。
            echo $this->_name;
        }
    }

    $computer = new Computer();
    $computer->_run();
?>

以上原理是：通过在类内创建公共方法，用来访问私有字段。然后在类外就可以调用该公共方法，从而达到访问私有字段的目的。

在类外对私有字段进行赋值和取值：

取值：

<?php
    class Computer{
        private $_name='联想';

        //对外的入口方法
        public function getName(){
            echo $this->_name;
        }
    }

    $computer = new Computer();
    $computer->getName();
?>

赋值并取值:

<?php
    class Computer{
        private $_name;

        //需要写一个对内的入口，对私有字段进行赋值
        public function setName($_name){

            //指向私有字段$_name，并将参数$_name（变量）的值赋给_name。
            //$this->_name是类的字段。
            $this->_name=$_name;
        }

        //对外的入口方法,访问私有字段$_name，也就是对私有字段取值。
        public function getName(){
            echo $this->_name;
        }
    }

    $computer = new Computer();
    //赋值
    $computer->setName('dell');
    //取值
    $computer->getName();
?>
多个字段情况下的赋值和取值

在这里，PHP内置了两个方法（拦截器）用于赋值和取值：__set(),__get()。

<?php
    class Computer{
        private $_name;
        private $_cpu;
        private $_keybord;

        //使用拦截器进行赋值和取值

        //赋值，需要注意：__set()必须传两个值（变量）,比如：$_key,$_value，可以随意命名
        public function __set($_key,$_value){
            //实际上$_key ='_name',$_value='联想'
            //相当于$this->_name='联想';
            $this->$_key=$_value;
        }

        //取值,__get()必须传一个值
        public function __get($_value){
            //返回相应的值
            return $this->$_value;

        }
    }
        //实例化对象
        $computer = new Computer();

        //赋值
        $computer->_name='联想';
        $computer->_cpu='i7';
        $computer->_keybord='xx';

        //取值
        echo $computer->_name;
        echo $computer->_cpu;
        echo $computer->_keybord;
?>

注意：__set()和__get()方法私有了，还可以执行，是因为目前程序的指针已经在类内了，而类内可以执行封装的方法。类内执行私有方法不会出现任何错误。
设置成私有方法是，它只需要间接拦截即可，拦截是在类内进行的
私有化：

<?php
    class Computer{
        private $_name;
        private $_cpu;
        private $_keybord;

        //使用拦截器进行赋值和取值

        //赋值，需要注意：__set()必须传两个值（变量）,比如：$_key,$_value，可以随意命名
        private function __set($_key,$_value){
            //实际上$_key ='_name',$_value='联想'
            //相当于$this->_name='联想';
            $this->$_key=$_value;
        }

        //取值,__get()必须传一个值
        private function __get($_value){
            //返回相应的值
            return $this->$_value;

        }
    }
        $computer = new Computer();
        //赋值
        $computer->_name='联想';
        $computer->_cpu='i7';
        $computer->_keybord='xx';

        //取值
        echo $computer->_name;
        echo $computer->_cpu;
        echo $computer->_keybord;
?>

常量（constant）

在类中可以定义常量，用来表示不会改变的值。对于从该类实例化的任何对象来说，常量值在这些对象的整个生命周期都保持不变。

<?php
    class Computer{
    //常量名用大写
        const NAME ='DELL';
    }

    //常量输出方法：类::常量

    echo Computer::NAME;
?>
静态类成员

有时候，可能需要创建供所有类实例共享的字段和方法，这些字段和方法与所有的类实例有关，但不能yo由任何特定对象调用。

静态字段：

<?php
    class Computer{
        public  static $_count = 0;
        public function _add(){
            //如果是静态成员，那就应该用self调用，而不是$this
            //self调用的时候，是需要$符号的
            //::是类中静态方法和静态属性的引用方法
            self::$_count++;

        }
    }



   $computer1 =new Computer();
   $computer1->_add();
   $computer1->_add();
   $computer1->_add();
   echo Computer::$_count;

   echo '<br />';
   $computer2 =new Computer();
   $computer2->_add();
   $computer2->_add();
   $computer2->_add();
   echo Computer::$_count;
?>

静态方法：

<?php
    class Computer{
        public static $_count = 0;
        public static function _run(){
            self::$_count++;
        }
   }
   Computer::_run();
   Computer::_run();
   Computer::_run();
   echo Computer::$_count;
?>

OOP继承

继承是从一个基类得到一个或多个类的机制。
PHP中，类继承通过extends关键字实现，继承自其它类的类成为子类或派生类，子类所有继承的类成为父类或基类。（PHP只支持单继承，不支持方法重载）。
一个简单的继承案例：

<?php
    //父类，电脑类
    class Computer{
        public $_name ='联想';

        public function _run(){
            echo '联想在运行';
        }
   }

   //子类，笔记本电脑类，继承自电脑类
   class NoteComputer extends Computer{

   }

   $notecomputer = new NoteComputer();
   echo $notecomputer->_name;
   $notecomputer->_run();
?>
字段和方法的重写（覆盖）

有时候，并不是特别需要父类的字段和方法，可以通过子类的重写来修改父类的字段和方法。
小例子：

<?php
    //父类，电脑类
    class Computer{
        public $_name ='联想';

        public function _run(){
            echo '联想在运行';
        }
   }

   //子类，笔记本电脑类，继承自电脑类
   class NoteComputer extends Computer{
    //若不需要父类的字段和方法，可以重写字段和方法覆盖
    public $_name='DELL';

    public function _run(){
        echo 'DELL在运行';
    }
   }

   $notecomputer = new NoteComputer();
   echo $notecomputer->_name;
   $notecomputer->_run();
?>
子类调用父类的字段或方法

为了安全，一般将父类的方法封装起来，这样外部就无法调用，只能被继承它的子类所看到。这时，就需要通过子类操作来调用父类。
例子：

<?php

    class Computer{
        //私有化，但是无法被子类继承，这时候应该用受保护的修饰符来封装
        protected $_name ='联想';

        protected function _run(){
            echo '联想在运行';
        }
   }


   class NoteComputer extends Computer{
    public function getTOP(){
        echo $this->_name;
    }
   }

   $notecomputer = new NoteComputer();
   $notecomputer->getTOP();
?>
通过重写调用父类的方法

有时候需要通过重写的方法里能够调用父类的方法内容，这时就必须使用语法：父类名::方法() 或者 parent::方法() 即可调用。后面的比较新，推荐后一种。
例子：

<?php

    class Computer{
        public $_name ='联想';

        public function _run(){
            echo '联想在运行';
        }
   }


   class NoteComputer extends Computer{
    public $_name='DELL';
    public function _run(){
        echo 'DELL在运行';
        echo parent::_run();
    }
   }

   $notecomputer = new NoteComputer();
    echo $notecomputer->_name;
    $notecomputer->_run();
?>
final关键字

可以防止类被继承，有时候只想做个独立的类，不想被其他类继承使用，那就需要用到final。建议只是单独的类都加上这个关键字。
例子：

<?php
//final如果加载类前， 表示该类不能被继承。
    // final class Computer{

    // }
    class Computer{
        //final如果加在方法前，表示不能重写此方法
        final public function _run(){

        }
    }

    class NoteComputer extends Computer{
        public function _run(){

        }
    }
?>

OOP多态

抽象类和方法（abstract）
抽象方法很特殊，只在父类中声明，但在子类中实现。只有声明abstract的类可以声明抽象方法。

规则：
1、抽象类不能被实例化，只能被继承；
2、抽象方法必须被子类方法重写。

<?php
//抽象类不能被实例化，也就是创建对象。
//只要类里有一个抽象方法，这个类就必须是抽象类。类前必须加上abstract
    abstract class Computer{
        //抽象类可以有成员字段
        public $_name ='联想';

        //在抽象类里创建一个抽象方法
        //抽象方法不能够实现方法体的内容
        abstract public function _run();
        //在抽象类里创建一个普通方法
        public function _run2(){
            echo '我是父类的普通方法';
        }

    }
//抽象类是用来给子类继承和资源共享的。
    class NoteComputer extends Computer{
        //抽象类里的抽象方法，子类必须重写，不然会报错。
        //抽象类的普通方法不需要重写，子类会直接继承下来
        public function _run(){
            echo '我是子类的方法';
        }
    }

    $notecomputer =new NoteComputer();
    $notecomputer->_run();
    $notecomputer->_run2();
    //可以调用成员字段
    echo  $notecomputer->_name;
?>

接口（interface）
接口定义了实现某种服务的一般规范，声明了所需函数和常量，但不指定如何实现，之所以不给出实现的细节，是因为不同的实体可能需要用不同的方式来实现公共的方法定义，关键是要建立必须实现一组一般原则，只要满足了这些原则才能说实现了这个接口。

规则：
1、类全部为抽象方法（不需要声明abstract）；
2、接口抽象方法必须是public；
3、成员（字段）必须是常量；
简单接口：

<?php
//接口也不能被实例化
//接口是为了规范实现它的子类，以达到统一目的。
    interface Computer{
        //成员字段必须是常量
        const NAME='联想';
        //接口里的所有方法都是抽象方法，不能写方法体
        //并且接口的抽象方法不需要写abstract
        public function _run();
        public function _run2();
    }
//子类继承接口的说法，叫实现。
    class NoteComputer implements Computer{
        public function _run(){
            echo '我重写了run';
        }
        public function _run2(){
            echo '我重写了run2';
        }
    }

    $notecomputer = new NoteComputer();
    $notecomputer->_run();
    $notecomputer->_run2();

    //接口::常量
    echo Computer::NAME;
?>
多态

多态是指OOP能够根据使用类的上下文来重新定义或改变类的性质或行为，或者说接口的多种不同的实现方式即为多态。把不同的子类对象都当做父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。

例子：

<?php 
//多态，即多种形态。
//一个动作由不同的人去执行，而产生不同的效果或者这结果，即为多态；
//一个人通过不同的状态去执行同一种动作，形成不同的结果，也称其为多态。

//创建一个接口来规范运行方法
interface Computer{
    public function version(); //这个方法表示采用什么电脑
    public function work();//这台电脑是怎么运行的。
    }

//创建一个笔记本类来实现接口
    class NoteComputer implements Computer{
        public function version(){
            echo '笔记本';
        }
        public function work(){
            echo '便捷式运行win7';
        }
    }

//创建一个台式机的类来实现接口
    class DesktopComputer implements Computer{
        public function version(){
            echo '台式机'; 
        }
        public function work(){
            echo '在工作中运行xp';
        }

    }

//创建一个用户
    class Person{

        //创建一个方法来接收电脑对象（笔记本电脑，台式电脑）
        //至于怎么接收，将他们的对象传进来就行了。
        public function _use($type){
            echo '这个人的';

            $type->version();
            $type->work();
        }
    }   

//现有一个接口，两个类。

    //创建笔记本对象
    $notecomputer = new notecomputer();

    //创建台式机对象
    $descktopcomputer = new DesktopComputer();

    //创建一个人对象
    $person =new Person();

    //使用笔记本电脑
    $person->_use($notecomputer);//这种传递叫 对象引用的传递。

    //这个人也可以换成使用台式机
    $person->_use($descktopcomputer);

 ?>

小结：多态的原理，就是类写好了，不去修改，只需要在类外调用参数的更改。而最后结果也会改变。

GabbyMrH
关注
专栏目录
Java面向对象的特性
博客记录学习轨迹，方便日后复习
11-21 3250
SCAU面向对象程序设计复习总结——关于Java语言面向对象特性的介绍
Java面向对象三大特性
weixin_63736489的博客
04-15 6001
面向对象特性之封装性，继承性，多态性
面向对象四大特性
Wzeefeng的博客
04-25 1843
面向对象四大特性：封装、抽象、继承、多态 封装：封装也叫作信息隐藏或者数据访问保护。类通过暴露有限的访问接口，授权外部仅能通过类提供的方式来访问内部信息或者数据。它需要编程语言提供权限访问控制语法来支持，例如 Java 中的 private、protected、public 关键字。封装特性存在的意义，一方面是保护数据不被随意修改，提高代码的可维护性；另一方面是仅暴露有限的必要接口，提高类的易...
C语言实现C++中面向对象特性
king110108的专栏
09-16 1593
C语言是面向过程的语言，因此用C语言进行面向对象编程，则需要做一些预处理。 一、使用结构体定义实现对象        面向对象的开发的核心思想就是对象，可以把任何事物抽象成对象，而把程序之间的交互以及调用，对象之间传递消息(实际上就是对象成员函数的调用)的形式来实现。 面向对象的语言专门引入了对象类型定义机制，用class关键字实现，C语言中没有专门针对面向对象的思想，也没有引入对象类型定义
java面向对象特性简述
juejiangjianchi的博客
08-20 2108
封装 官方解释： 面向对象的封装就是把描述一个对象的属性和行为的代码封装在一个“模块”中，也就是一个类中，属性用变量定义，行为用方法进行定义，方法可以直接访问同一个对象中的属性。 简述： 封装的作用就是将某个事物所有的属性归为一类， 对象所有的动作和行为全部由对象自己来完成。 作用：实现程序的高内聚，低耦合。 抽象 官方解释： 抽象就是找出一些事物的相似和共性之处，然后将这些事物归为一个类，这个类...
Java面向对象特性
weixin_45696001的博客
11-13 1482
文章目录Java面向对象特性Java语言的OPP特性封装继承多态Java中类和对象的基本概念类的定义类的基本结构类的声明类体类的封装以及信息隐藏成员变量成员方法**方法的声明**方法中的调用参数的传递可变参数列表方法的重载this构造方法**定义格式：****构造方法的特点：****默认构造方法****重载构造方法**访问控制privatedefaultprotectedpublic内部类内部类的概念内部类的使用1.内部类作为外包类的一个成员使用2.外包类的语句块中定义内部类3.在外包类以外的其他类中访问内
面向对象的三大特性
qq_44235531的博客
09-03 7562
面向对象的三大特性
面向对象的四大特性概念
k673656的博客
10-16 2044
面向对象四大特性
面向对象有哪些特性？
qq_45836005的博客
12-30 1898
1、面向对象有封装、继承 、抽象、多态等4个主要的特征。 2、封装：面向对象的封装就是把描述一个对象的属性和行为的代码封装在一个类中，有些属性是不希望公开的，或者说被其他对象访问的，所以我们使用private修饰该属性，使其隐藏起来；类中提供了方法（用public修饰），常用的是get、set方法，可以操作这些被隐藏的属性，其他类可以通过调用这些方法，改变隐藏属性的值！ 下面的回答是更高要求，不需要学生必须掌握： 封装是保证软件部件具有优良的模块性的基础，封装的目标就是要实现软件部件的“高内聚、低耦合”，防
java-面向对象特性PPT.ppt
10-31
"java-面向对象特性PPT" 本资源摘要信息主要讲解了面向对象编程的基本概念、面向对象设计、类和对象的概念、Java中的类和对象的使用等知识点。 面向对象编程是一种编程思想，强调以对象为中心来思考问题。面向对象...
JavaScript的面向对象特性浅析与范例.pdf
最新发布
01-02
"JavaScript面向对象特性浅析与范例" JavaScript是一种基于原型的解释型语言，它允许在任意时刻给一个对象添加任意多的属性和方法。 JavaScript的面向对象特性是指它可以实现面向对象编程的部分特性，而不是完全...
javascript 的面向对象特性参考
12-12
javascript 的面向对象特性参考。 这是我学习javascript中面向对象特性的一点总结。希望对具有其他语言的面向对象设计经验的朋友理解javascript的OO有所帮助。我具有c++,java和python的面向对象设计的经验。 总的...
javascript面向对象特性代码实例
10-25
以上就是本篇文章所介绍的JavaScript面向对象特性的核心知识点。通过实例代码的展示，作者带领读者深入了解了这些特性在实际编程中的应用。需要注意的是，由于篇幅限制，这里只能概述文章中的一些要点，具体代码实例...
Java语言的面向对象特性.pdf
07-11
Java语言的面向对象特性还包括动态性，这意味着在运行时，程序可以根据对象的实际类型执行相应的操作。例如，多态的实现依赖于Java的动态绑定（dynamic binding），也称为晚期绑定（late binding），在编译期间无法...
使用MySQLi操作数据库
GabbyMrH
04-04 1013
建立和断开连接 创建一个mysqli的对象： $_mysqli = new mysqli(); 连接MySQL的主机、用户、密码、数据库 $_mysqli-&gt;connect('localhost','root','root','test'); 创建带连接参数的mysqli对象 $_mysqli = new mysqli('localhost','root','root...
PHP创建与解析XML
GabbyMrH
04-03 869
定界符：&lt;&lt;&lt;EOF......EOF 用于存放复杂，多样化的字符串。 &lt;&lt;&lt;EOF &lt;a href="javascript:edit('asd', 'aaa')"&gt;编辑&lt;/a&gt; | &lt;font color="#ccc"&gt;删除&lt;/font&gt; &
函数和自定义函数
GabbyMrH
03-30 790
标准函数 标准函数为系统内置函数，PHP发行包中有1000多种内置函数。我们常用的：echo、MD5、print_r…等等. 自定义函数 创建函数,function()： &lt;?php function functionName(){ echo '这是一个无参数无返回的自定函数'; //无参数表示函数名括号内是空的，无返回指函数程序里没有`return`...
数组相关
GabbyMrH
03-26 339
数组是键值对的形式，键（key）默认自动生成，值（value）手动赋予； 输出数组 1、数组不能直接输出，因为数组是键值对的形式，如果需要打印数组中某个元素，需要打印出该数组对应的下标，如果该数组赋值给了变量，则同理： 如：echo $userNames[2], 如果需要打印整个数组信息，则：print_r($userNames); 2、range()自动生成数组，如：range（’...
Java语言的面向对象特性详解
"Java语言的面向对象特性" Java语言的面向对象特性是其核心设计原则之一，这一特性使得Java成为一种强大的、适用于复杂系统开发的编程语言。面向对象编程（Object-Oriented Programming, OOP）的基本思想是通过模拟...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值