面向对象_面向对象编程 - CSDN
面向对象 订阅
面向对象(Object Oriented)是软件开发方法。面向对象的概念和应用已超越了程序设计和软件开发,扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。面向对象是一种对现实世界理解和抽象的方法,是计算机编程技术发展到一定阶段后的产物。面向对象是相对于面向过程来讲的,面向对象方法,把相关的数据和方法组织为一个整体来看待,从更高的层次来进行系统建模,更贴近事物的自然运行模式。 [1] 展开全文
面向对象(Object Oriented)是软件开发方法。面向对象的概念和应用已超越了程序设计和软件开发,扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。面向对象是一种对现实世界理解和抽象的方法,是计算机编程技术发展到一定阶段后的产物。面向对象是相对于面向过程来讲的,面向对象方法,把相关的数据和方法组织为一个整体来看待,从更高的层次来进行系统建模,更贴近事物的自然运行模式。 [1]
信息
作    用
软件开发
使用领域
CAD技术、人工智能等
中文名
面向对象
外文名
Object Oriented
面向对象早期发展
早期的计算机编程是基于面向过程的方法,例如实现算术运算1+1+2 = 4,通过设计一个算法就可以解决当时的问题。随着计算机技术的不断提高,计算机被用于解决越来越复杂的问题。一切事物皆对象,通过面向对象的方式,将现实世界的事物抽象成对象,现实世界中的关系抽象成类、继承,帮助人们实现对现实世界的抽象与数字建模。通过面向对象的方法,更利于用人理解的方式对复杂系统进行分析、设计与编程。同时,面向对象能有效提高编程的效率,通过封装技术,消息机制可以像搭积木的一样快速开发出一个全新的系统。面向对象是指一种程序设计范型,同时也是一种程序开发的方法。对象指的是类的集合。它将对象作为程序的基本单元,将程序和数据封装其中,以提高软件的重用性、灵活性和扩展性。 [2]  面向对象的思想已经涉及到软件开发的各个方面。如,面向对象的分析(OOA,Object Oriented Analysis),面向对象的设计(OOD,Object Oriented Design)、以及我们经常说的面向对象的编程实现(OOP,Object Oriented Programming)。 [2] 
收起全文
精华内容
参与话题
  • 面向对象思想总结

    万次阅读 多人点赞 2018-07-23 17:31:53
    面向对象和面向过程的思想有着本质上的区别,作为面向对象的思维来说,当你拿到一个问题时,你分析这个问题不再是第一步先做什么,第二步再做什么,这是面向过程的思维,你应该分析这个问题里面有哪些类和对象,这是...

     

    一、面向过程的思想和面向对象的思想

    面向对象和面向过程的思想有着本质上的区别作为面向对象的思维来说,当你拿到一个问题时,你分析这个问题不再是第一步先做什么,第二步再做什么,这是面向过程的思维,你应该分析这个问题里面有哪些类和对象,这是第一点,然后再分析这些类和对象应该具有哪些属性和方法。这是第二点。最后分析类和类之间具体有什么关系,这是第三点。

          面向对象有一个非常重要的设计思维:合适的方法应该出现在合适的类里面。

    二、简单理解面向对象

    就是在程序里面首先分解出来的应该是注意不再是一步一步的过程了,而是首先考虑在这个问题域里面或者程序里面应该具有有哪些对象,所以从现在开始考虑任何问题脑子里不要再想着我实现这件事我第一步应该干什么,第二步应该干什么,如果这样想,那就是面向过程的思维了。面向对象的思维是,当我碰到这个问题域的时候,碰到这个程序的时候,我首先应该把这个问题里有哪些对象,对象与对象之间有什么关系抽象出来。

    三、面向对象的设计思想

    面向对象的基本思想是,从现实世界中客观存在的事物出发来构造软件系统,并在系统的构造中尽可能运用人类的自然思维方式。

    面向对象更加强调运用人类在日常生活的逻辑思维中经常采用的思想方法与原则,如抽象、分类,继承、聚合、多态等。             人在思考的时候,首先眼睛里看到的是一个一个的对象。

    四、对象和类的概念

     对象是用于计算机语言对问题域中事物的描述,对象通过“属性(attribute)”和“方法(method)”来分别对应事物所具有的静态属性和动态属性

         类是用于描述同一类的对象的一个抽象的概念,类中定义了这一类对象所具有的静态属性和动态属性

        类可以看成一类对象的模板,对象可以看成该类的一个具体实例

          eg.什么叫瓶子?

         瓶子的定义:具有某些类特征的东西就是瓶子,比分说什么样的形状,比方说有个口,能倒水,能装水,一般有个盖等等。给瓶子下定义的过程,其实就是把瓶子里的某些东西抽象出来了,所以瓶子在这里是叫做一类事物的一个抽象,在你脑子里有瓶子的概念,可瓶子的概念在你脑子里到底是什么呢?瓶子的概念在你脑子里叫做一类事物的一个抽象。怎么抽象的呢?你往往抽象的是这两个方面:第一个方面我们叫它静态的属性,瓶子应该具有哪些特征,比分说瓶子应有个口,这是它的具有的一个静态属性,瓶子一般有一个盖,这也是它的具有一个静态属性,除此之外,你还可能给它总结动态的属性,什么动态的属性呢?比放说瓶子能倒水,这是它的动态属性。瓶子这个概念在你脑子里如果你细细的思维的话,其实你给它做了两方面的总结,一方面是静态的,一方面是动态的。反映到JAVA的类上,一个就是成员变量(静态属性),一个就是方法(动态属性)方法是可以执行的,可以动的。成员变量是某一个类的静态属性。所以你脑子里瓶子的概念实际上是一类事物的一个抽象,这种东西我们叫它类,椅子是类,桌子是类,学生是类。什么是对象呢?这一类事物的具体的某个实例就叫做对象。所以一类事物的具体的某一个东西,符合这类事物具体的特征的某个东西就叫做对象瓶子是一个类,某个瓶子就是瓶子这个类里面的一个对象。

    五、如何抽象出一个类?

    有两个方面,一方面是它的静态属性,另一方面是它的动态属性。反映到JAVA里面的类怎么包装它呢?一方面成员变量,另一方面是方法。

      eg.职员这个类该怎么抽象出来?也是从两个方面,一方面是它的静态属性,另一方面它的动态属性

    职员有哪些属性呢?有姓名,年龄,目前工资数额等属性,他有哪些方法呢?让这个职员来显示姓名,显示年龄,修改姓名,领取工资。当然显示姓名,显示年龄,修改姓名,领取工资这些也可以让别人来做,但面向对象的设计思维是最合适的方法应该出现在最合适的类里面显示姓名,显示年龄,修改姓名,领取工资由谁来做更合适呢,那就是职员自己最合适。所以这些方法应该出现在职员这个类里面。

    对于类来说,它有一些属性或者称为成员变量,以后说属性或者成员变量指的是同一回事。具体的对象他有没有相关的一些属性或者叫成员变量呢?有,每一个人都有一份,只不过是取值不同而已。如从职员这个类实例化出来的两个职员:职员A和职员B,他们都有姓名,年龄,目前工资数额这些属性,但他们的名字,年龄,领取的工资数额都不一样。这样就能把职员A和职员B区分开来了,正是因为他们的属性值不一样,所以这个对象才能和另外的对象区分开来,所以通过属性是可以区分两个对象的。猫是一个类,这只猫是一个对象,这只猫和另外一只猫该怎么区分开来呢?那就得看你的猫这个类是怎么定义的了,猫有猫毛,毛有颜色。OK,这只猫是黑猫,另一只猫是白猫,这样通过猫毛的颜色区分开来了。如果只定义一个,如捉老鼠,白猫也能捉,黑猫也能捉,这样就没办法区分出黑猫和白猫了,所以根据方法是没办法区分两个对象的。所以每个对象都有自己的属性,属性值和另外一个对象一般是不一样的

    一定要区分类和对象,什么叫做类?什么叫做对象?类是一类事物的一个抽象,具有共同特征的一类事物的一个抽象。对象是这个类具体的某一个实例,所以以后说实例(instance)或者说对象(object)指的是同一回事。

    六、类(对象)之间的关系

    一.关联关系(最弱的一种关系)

    类和类之间是有关系的,如学生和老师这两个类,老师可以教学生,学生可以向老师学习。这就是他们之间的关系。关系和关系之间是不同的,你和你老婆的关系和你和你其他女朋友的关系是不能混为一谈的。关系最弱的一种关系叫关联关系。关联关系反应到代码上往往是一个类的方法里面的参数是另一个类的具体的某一个对象,比如教授教研究生,教哪个研究生,教是教授这个类里面的一个方法,某个研究生是研究生这个类里面的一个具体的对象。关联关系是最弱的一种关系,咱们两个类之间有关系,或者两个对象之间有关系,但关系不是很紧密。

    二.继承关系(比较强的一种关系)

    继承关系封装了这样一种逻辑:“XX是一种XX”,只要这东西能说通了,就可以考虑用继承关系来封装它如:游泳运动员从运动员继承,游泳运动员是一种运动员,这能说得通,所以游泳运动员就是从运动员继承过来的,游泳运动员和运动员就是一种继承关系。学生是一个人,学生从人继承,老师是一个人,老师也从人继承,学生是一种老师,这说不通,所以学生和老师就不存在继承关系。所以将来做设计的时候要分清继承关系很简单,你只要说通这么一句话:“XX是一种XX”。OK,那他们之间就是继承关系。篮球运动员是一种球类运动员,这说得通,所以篮球运动员从球类运动员继承,这样继承很有可能会产生一棵继承树,运动员派生出来,派生出来的意思是游泳运动员这个类、球类运动员这个类、射击运动员类从它继承,相当于运动员派生出来了这些个不同的运动员,包括游泳的,球类的,射击的。球类的再派生足球的,篮球的,排球的。这就是一棵继承树,不过这棵树是比较理想化的情况,只有一个根节点。但实际当中,我们真实世界当中的继承关系不一定只从一个类继承,一个类可能从多个类继承过来,比如说:金丝猴从动物这个类继承,这很正常,但我还有另外一个专门的类:“应该受到保护的东西”,这也是一个类,金丝猴应该受到保护,所以金丝猴是一种应该受到保护的东西。所以金丝猴从“应该受到保护的东西”这个类继承过来。所以在现实情况当中,一个类完完全全有可能从多个不同的类继承,C++正是因为想封装这种继承关系,所以C++存在多重继承。

    三.聚合关系(整体和部分)(比较强的一种关系)

    什么是聚合?聚合就是一个整体与部分的关系我们说“XX是XX的一部分”,只要说得通,那么他们之间的关系就是聚合关系队长是球队的一部分,队员是球队的一部分。所以队长和球队是聚合关系,队员和球队也是聚合关系。脑袋是人的以部分,身体和胳膊也是人的一部分,因此脑袋,身体和胳膊与人都是聚合关系。聚合关系分得再细一点的话就可以分成聚集关系和组合关系比如球队、队长,队员,这三者是聚集关系,假如这个队长既是足球的队长,同时也是篮球的队长,一个人分属两个不同的球队,这是可以的,球队与队长之间没有我离不了你,你离不了我这种情况,所以如果分得更细的话,这种就叫做聚集关系。还有一种情况叫组合,组合说的是咱们俩密不可分,我是你必不可少的一部分。一个人的脑袋不可能既属于你又属于别人,身体也一样,不可能既属于你又属于别人。所以你的身体,脑袋和你是密不可分的,这是一种更加严格的聚合关系,专门给它取了个名字叫组合。

    四.实现关系

    作为父类来说,我觉得我应该具有这样一个方法,但我不知道怎么去实现,谁去实现,我的子类去实现,这就是实现关系。和实现关系息息相关的还有一种关系叫多态。

    五.多态

    六、Java与面向对象

    对象和类是分不开的,必须首先定义类才能有对象。首先定义方法才能调用。对象是JAVA里面的核心,做任何东西你首先都得给我造出一个对象才能做。静态属性简称属性,也叫成员变量,以后说属性或者说成员变量它们指的都是同一回事。

      整个类可以看作是静态的属性还有方法他们之间的一个综合。怎么抽象出一个类的概念,还是那句话,你必须抽象出两个方面来,第一方面是看他们的静态属性,他们有哪些成员变量,第二方面是看他们的有哪些方法。

      写JAVA程序时,我们一上来写的就是public class(声明一个类),在这个class里面我们写的是成员变量和方法。

    每一个JAVA里面的class(类)都对应了我们现实生活中某一类事物的一个抽象比如说要在JAVA里面封装一只狗,具体怎么封装,如何写代码,代码如下:

    package cn.javastudy.summary;
    /**
     * 一类事物封装到JAVA里面首先得写class,定义这个类,类名是什么可以自己取。
     * 这里把类名叫做Dog
     */
    public class Dog {
        /**
         * 接下来就是写这个狗这个类的属性或者叫成员变量,
         * 比如说狗这个类的毛的颜色,怎么定义这个属性呢,
         * 首先得定义毛的一个类型,如使用int来定义毛的颜色类型
         */
        int furcolor; //定义属性:毛的颜色
        float height; //定义属性:狗的高度
        float weight; //定义属性:狗的体重
        
        /**
         * 狗的颜色,高度,体重这些属性定义完了,接下来要定义的就是方法了。
         * 如写一个CatchMouse()方法,捉老鼠的方法。
         * CatchMouse这个方法里面有一个对象类型的参数,捉哪一只老鼠,这个对象参数是属于Mouse这个类的
         * @param m
         */
        void CatchMouse(Mouse m){
                //在方法体内写捉老鼠这个过程,怎么捉,跑着捉,走着捉
                System.out.println("我捉到老鼠了,汪汪!,老鼠要尖叫了!");
                /**
                 * 老鼠尖叫一声,表示被狗咬到了,咬到了能不叫吗,很自然而然地想到,
                 * 尖叫(scream())这个方法是属于Mouse这个类里面的某一个方法。
                 * 老鼠自己调用它,让它自己尖叫。这就是面向对象的思维。
                 */
                m.scream();
        }
        
        public static void main(String[] args) {
            Dog  d = new Dog();//首先用new关键字创建一只狗
            Mouse m=new Mouse();//造出一只老鼠。
            d.CatchMouse(m);//然后用这只狗去抓老鼠,让狗调用CatchMouse()方法去捉某只老鼠。
        }
    }

     

    package cn.javastudy.summary;
    /**
     * 封装的老鼠类
     */
    public class Mouse {
        /**
         * 老鼠自己有一个发出尖叫的方法
         * 当被狗咬到时就会发出尖叫
         */
        public void scream() {
            System.out.println("我被狗咬到了,好痛啊!");
        }
    
    }

    从这个意义上来讲,JAVA里面的每定义一个类实际上就相当于一种新的数据类型。就跟int ,float, String等一样,不过是一种新定义的类型而已。

    八、为什么使用面向对象编程?

    面向对象编程:一组对象互相配合通过沟通完成特定功能

      做软件苦苦追求的一种境界是可重用性(reusable),可扩展性。如果是面向过程,一般情况是属性和方法它们是分开的,他们不是聚合的关系,不是合在一起的,这样要复用起来比较麻烦,复用的层次只是局限于方法这个层次上,而面向对象则不同,它是把属性和方法综合在一个里面。综合在一起复用的时候是整个对象进行复用。所以面向对象和面向过程相比,前者更加容易让我们达到可重用性。

     

     

     

     

    展开全文
  • 面向对象

    千次阅读 2020-05-27 11:43:16
    面向对象的特征:封装、继承、多态、抽象。 封装:就是把属性私有化,提供公共方法访问私有对象。举个简单的例子,我们去Apple店里买个iPhoneX,我们不需要知道它是怎么制造的,我们只需要知道它能用来打电话,上网和...

    面向对象的特征:封装、继承、多态、抽象。
    封装:就是把属性私有化,提供公共方法访问私有对象。举个简单的例子,我们去Apple店里买个iPhoneX,我们不需要知道它是怎么制造的,我们只需要知道它能用来打电话,上网和用来装B就行了。对于程序设计,用户只需要知道类中某个方法实现了什么样的功能,需要该功能的时候直接去调用就行了,不用去关心方法内部的实现细节。
    继承:当多个类具有相同的特征(属性)和行为(方法)时,可以将相同的部分抽取出来放到一个类中作为父类,其它类继承这个父类。继承后子 类自动拥有了父类的属性和方法,比如猫,狗,熊猫他们共同的特征都是动物,有颜色,会跑,会叫等特征。我们可以把这些特征抽象成我一个Animal类(也就是父类)。然而他们也有自己独特的特性,比如猫会抓老鼠,喵喵叫,熊猫有黑眼圈,能吃竹子,狗会汪汪。于是我们就根据这些独特的特征分别抽象出来Cat,Dog,Panda类等。他们拥有Animal类的一般属性和方法,也拥有自己特有的某些属性和方法。但特别注意的是,父类的私有属性(private)和构造方法不能被继承。另外子类可以写自己特有的属性和方法,目 的 是实现功能的扩展,子类也可以复写父类的方法,即方法的重写。子类不能继承父类中访问权限private的成员变量和方法 。
    多态:简单来说就是“一种定义,多种实现”。同一类事物表现出多种形态。Java语言中有方法重载和对象多态两种形式的多态。方法重载:在一个类中,允许多个方法使用同一个名字,诞生方法的参数不同,完成的功能也不同。对象多态:子类对象可以与父类对象进行互相转换,而且根据其使用的子类的不同,完成的功能也不同。
    抽象:抽象是从许多事物中,舍弃个表的,非本质的属性,抽取出共同的,本质的属性的过程。例如教师,学生和工人,他们共同的特质是人类,既然是人类就有共同的属性:性别,年龄,身高,体重等。抽象的过程就是比较的过程,通过比较找出事物之间的共同属性,通过比较区分本质。

    展开全文
  • 面向对象基本概念

    万次阅读 多人点赞 2020-05-09 14:56:04
    面向对象就是:把数据及对数据的操作方法放在一起,作为一个相互依存的整体——对象。对同类对象抽象出其共性,形成类。类中的大多数数据,只能用本类的方法进行处理。类通过一个简单的外部接口与外界发生关系,对象...

    面向对象就是:把数据及对数据的操作方法放在一起,作为一个相互依存的整体——对象。对同类对象抽象出其共性,形成类。类中的大多数数据,只能用本类的方法进行处理。类通过一个简单的外部接口与外界发生关系,对象与对象之间通过消息进行通信。程序流程由用户在使用中决定。对象即为人对各种具体物体抽象后的一个概念,人们每天都要接触各种各样的对象,如手机就是一个对象。

    面向对象编程(OOP: object-oriented programming)

    面向对象

     

    面向对象与面向过程的区别

    项目名称 面向对象程序设计 面向过程程序设计(也叫结构化编程)
    定义 面向对象顾名思义就是把现实中的事务都抽象成为程序设计中的“对象”,其基本思想是一切皆对象,是一种“自下而上”的设计语言,先设计组件,再完成拼装。 面向过程是“自上而下”的设计语言,先定好框架,再增砖添瓦。通俗点,就是先定好main()函数,然后再逐步实现mian()函数中所要用到的其他方法。
    特点 封装、继承、多态 算法+数据结构
    优势 适用于大型复杂系统,方便复用、 适用于简单系统,容易理解
    劣势 比较抽象、性能比面向过程低 难以应对复杂系统,难以复用,不易维护、不易扩展
    对比 易维护、易复用、易扩展,由于面向对象有封装、继承、多态性的特性,可以设计出低耦合的系统,使系统 更加灵活、更加易于维护  性能比面向对象高,因为类调用时需要实例化,开销比较大,比较消耗资源;比如单片机、嵌入式开发、 Linux/Unix等一般采用面向过程开发,性能是最重要的因素。 
    设计语言 Java、Smalltalk、EIFFEL、C++、Objective-、C#、Python等 C、Fortran
    使用场景

    30种编程语言的比较选择问题https://blog.csdn.net/ljy1988123/article/details/7782700

    类与对象的主要区别

    对象:对象是类的一个实例(对象不是找个女朋友),有状态和行为。例如,一条狗是一个对象,它的状态有:颜色、名字、品种;行为有:摇尾巴、叫、吃等。 

    :类是一个模板,它描述一类对象的行为和状态。

    1、面向对象三大主要特征(理解)

    ①封装

    两层含义:一层含义是把对象的属性和行为看成一个密不可分的整体,将这两者“封装”在一个不可分割的独立单元(即对象)中;另一层含义指“信息隐藏”,把不需要让外界知道的信息隐藏起来,有些对象的属性及行为允许外界用户知道或使用,但不允许更改,而另一些属性或行为,则不允许外界知晓,或只允许使用对象的功能,而尽可能隐藏对象的功能实现细节。

    封装的优点

    • 良好的封装能够减少耦合,符合程序设计追求“高内聚,低耦合”。

    • 类内部的结构可以自由修改。

    • 可以对成员变量进行更精确的控制。

    • 隐藏信息实现细节。

    实现Java封装的步骤

    1. 修改属性的可见性来限制对属性的访问(一般限制为private),例如:

    public class Person { 
        private String name; 
        private int age; 
    }

    这段代码中,将 name 和 age 属性设置为私有的,只能本类才能访问,其他类都访问不了,如此就对信息进行了隐藏。

    2. 对每个值属性提供对外的公共方法访问,也就是创建一对赋取值方法,用于对私有属性的访问,例如:

    public class Person{ 
        private String name;
        private int age; ​ 
        private boolean alive;
    
        public int getAge(){
            return age; 
        } 
    
        public void setAge(int age){ 
            this.age = age; 
        } ​
    
        public String getName(){ 
            return name; 
        } ​
     
        public void setName(String name){ 
            this.name = name; 
        }
    
        public boolean isAlive() {
    		return alive;
    	}
    
    	public void setAlive(boolean alive) {
    		this.alive = alive;
    	}
    
    }

    采用 this 关键字是为了解决实例变量(private String name)和局部变量(setName(String name)中的name变量)之间发生的同名的冲突。

    封装同时可以提高代码的安全性,例如普通的类属性不是private修饰就直接可以通过“对象名.属性 = xxx”对其赋值,但当我们用private修饰该属性后就不能这样对其做任意的修改了,而且我们还可以在其对外的访问方法中进行合法值校验。比如上例中的setAge()就可以更改为:

    public void setAge(int age){
        if(age > 120)
            System.out.println("Age setting error");
        else
            this.age = age;
    }

     封装的使用细节:

    1. 一般使用private访问权限
    2. 提供相应的get、set方法来访问相关属性,这些方法通常是public修饰的。以提供对属性的赋值与读取操作。(注意!boolean变量的get方法是is开头。)
    3. 一些只用于本类的辅助性方法,可以使用private修饰,希望其他类调用的方法用public修饰。

    this与super关键字:

    1、this关键字代表当前对象

    2、super可以理解为是指向自己超(父)类对象的一个指针,而这个超类指的是离自己最近的一个父类。  

     this与super对比

    • this.属性 操作当前对象的属性
    • this.方法 调用当前对象的方法 
    • 引用构造函数:调用本类中另一种形式的构造函数(应该为构造函数中的第一条语句)。
    • 普通的直接引用:与this类似,super相当于是指向当前对象的父类,这样就可以用super.xxx来引用父类的成员。
    • 子类中的成员变量或方法与父类中的成员变量或方法名同名时,表示调用父类的成员
    • 引用构造函数:调用父类中的某一个构造函数(应该为构造函数中的第一条语句)。默认在构造函数第一条语句是“super();”,无论写与否。
    • super(参数):调用基类中的某一个构造函数(应该为构造函数中的第一条语句)
    • this(参数):调用本类中另一种形成的构造函数(应该为构造函数中的第一条语句)
    • 调用super()必须写在子类构造方法的第一行,否则编译不通过。每个子类构造方法的第一条语句,都是隐含地调用 super(),如果父类没有这种形式的构造函数,那么在编译的时候就会报错。
    • super() 和 this() 类似,区别是,super() 从子类中调用父类的构造方法,this() 在同一类内调用其它方法。
    • super() 和 this() 均需放在构造方法内第一行。
    • 尽管可以用this调用一个构造器,但却不能调用两个。
    • this 和 super 不能同时出现在一个构造函数里面,因为this必然会调用其它的构造函数,其它的构造函数必然也会有 super 语句的存在,所以在同一个构造函数里面有相同的语句,就失去了语句的意义,编译器也不会通过。
    • this() 和 super() 都指的是对象,所以,均不可以在 static 环境中使用。包括:static 变量,static 方法,static 语句块。
    • 从本质上讲,this 是一个指向本对象的指针, 然而 super 是一个 Java 关键字。

    ②继承

    继承是java面向对象编程技术的一块基石,因为它允许创建分等级层次的类。

    继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为。

    类的继承格式:

    class 父类 { }

    class 子类 extends 父类 { }

    继承的类型:需要注意的是 Java 不支持多继承,但支持多重继承。

     继承的好处:

    (1)提高类代码的复用性

    (2)提高了代码的维护性

    (3)使得类和类产生了关系,是多态的前提(它也是继承的一个弊端,类的耦合性提高了)

    继承的特性

    • 子类拥有父类非 private 的属性、方法。

    • 子类可以拥有自己的属性和方法,即子类可以对父类进行扩展。

    • 子类可以用自己的方式实现父类的方法,即重写父类方法。

    • Java 的继承是单继承,但是可以多重继承,单继承就是一个子类只能继承一个父类,多重继承就是,例如 A 类继承 B 类,B 类继承 C 类,所以按照关系就是 C 类是 B 类的父类,B 类是 A 类的父类,这是 Java 继承区别于 C++ 继承的一个特性。

    • 继承可以使用 extends 和 implements 这两个关键字来实现继承,而且所有的类都是继承于 java.lang.Object,当一个类没有继承的两个关键字,则默认继承object(这个类在 java.lang 包中,所以不需要 import)祖先类。

    • 提高了类之间的耦合性(继承的缺点,耦合度高就会造成代码之间的联系越紧密,代码独立性越差)。

     final关键字:

    表示最终的意思,可以修饰类、成员变量、成员方法

    • 修饰类:类不可以被继承
    • 修饰成员变量:变量为常量,值不可以改变
    • 修饰成员方法:方法不能被重写
    • final还可以修饰局部变量:①修饰基本数据类型,值不能改变;②修饰引用数据类型,地址值不能改变

     static关键字(静态):

    static表示静态的意思,既可以修饰成员变量,又可以修饰成员方法,还有一种特殊用法修饰类

    (1)、修饰成员变量表示静态变量:static变量也称作静态变量,静态变量和非静态变量的区别是:静态变量被所有的对象所共享,在内存中只有一个副本,它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的,在创建对象的时候被初始化,存在多个副本,各个对象拥有的副本互不影响。static成员变量的初始化顺序按照定义的顺序进行初始化。static不能修饰局部变量。

    (2)、修饰成员方法:static方法一般称作静态方法,由于静态方法不依赖于任何对象就可以进行访问,因此对于静态方法来说,是没有this的,因为它不依附于任何对象,既然都没有对象,就谈不上this了。并且由于这个特性,在静态方法中不能访问类的非静态成员变量和非静态成员方法,因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。

    (3)static代码块:static关键字还有一个比较关键的作用就是 用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方,类中可以有多个static块。在类初次被加载的时候,会按照static块的顺序来执行每个static块,并且只会执行一次。

    特点:
        1)随着类的加载而加载
        2)优先于对象存在
        3)被所有的对象所共享
            该特点是我们使用static的条件

    注意事项:
        1)在静态方法中,不能出现this/super
        2)静态方法只能访问静态成员;非静态方法既可以访问静态成员,也可以访问非静态成员
        3)工具类里面的成员一般来说是静态成员(目的:节约内存空间)

    静态变量和成员变量的区别
    1)所属不同
          静态变量属于类,也称为类变量
          成员变量属于对象,也称为实例变量
    2)内存中位置不同
          静态变量存在方法区
          成员变量存在堆中
    3)出现的时间不同
          静态变量随着类的加载而加载,随着类的消亡而消亡
          成员变量随着对象的创建而创建,随着对象的消失而消失
    4)调用方式不同
          静态变量通过类名调用,也可以通过对象名调用(不建议)
          成员变量只能通过对象名调用
    所以,成员变量可以称为对象的特有数据,静态变量称为对象的共享数据

    成员变量与局部变量的区别
    1)在类中的位置不同
           成员变量:在类中方法外面
           局部变量:在方法或者代码块中,或者方法的声明上(即在参数列表中)
    2)在内存中的位置不同,可以看看Java程序内存的简单分析
           成员变量:在堆中(方法区中的静态区)
           局部变量:在栈中
    3)生命周期不同
          成员变量:随着对象的创建而存在,随着对象的消失而消失
          局部变量:随着方法的调用或者代码块的执行而存在,随着方法的调用完毕或者代码块的执行完毕而消失
    4)初始值
          成员变量:有默认初始值
          局部变量:没有默认初始值,使用之前需要赋值,否则编译器会报错(The local variable xxx may not have been initialized)

    package se01.day02;
    
    //子父类静态代码块、构造代码块、构造方法
    class Fu{
    	String name;
    	int age;
    	
    	{
    		System.out.println("构造代码块Fu");
    	}
    	
    	static{
    		System.out.println("静态代码块Fu");
    	}
    	
    	public Fu() {
    		System.out.println("无参构造方法Fu");
    	}
    
    	public Fu(String name, int age) {
    		this.name = name;
    		this.age = age;
    		System.out.println("有参构造Fu");
    	}
    
    }
    public class Zi extends Fu{
    	int id;
    	{
    		System.out.println("构造代码块Zi");
    	}
    	static{
    		System.out.println("静态代码块Zi");
    	}
    	public Zi() {
    		System.out.println("无参构造方法Zi");
    	}
    
    	public Zi(String name, int age) {
    		this.name = name;
    		this.age = age;
    		System.out.println("有参构造Zi");
    	}
    	public static void main(String[] args) {
    		new Zi("小明",13);
    	}
    }
    
    ==========================执行结果为====================================
    静态代码块Fu
    静态代码块Zi
    构造代码块Fu
    无参构造方法Fu
    构造代码块Zi
    有参构造Zi

    static特殊用法(static修饰类):  如果一个类要被声明为static的,只有一种情况,就是静态内部类。如果在外部类声明为static,程序会编译都不会过。(在内部类中详细讲解)

    Question:在什么情况下需对属性和方法加上static关键字?

    在编写的代码中,static定义的属性出现几率不是特别高,一般只有在描述共享属性概念或者是不受实例化对象限制的属性时才会使用static定义属性,而大部分情况下依然都使用非static属性。

    产生实例化对象是因为在堆内存中可以保存属性信息,所以如果一个类中没有属性产生,就自然也没有必要去开辟堆内存保存属性内容了,所以这个时候就可以考虑类中的方法全部使用static声明。

    NOTICE:在JDK1.7之前,Java一直存在一个Bug,可以先执行静态代码块来代替主方法。按照标准来说,所有的程序应该都是从主方法开始执行,但是下例却先执行静态代码块

    	public static void main(String[] args) {
    		System.out.println("你好,世界");
    	}
    	
    	static{
    		System.out.println("Hello World");
    	}
    
    ===========输出结果为==============
    Hello World
    你好,世界

    ③多态

    多态是同一个行为具有多个不同表现形式或形态的能力。

    多态的体现

    Java语言中含有方法重载与对象多态两种形式的多态:

    方法重载:在一个类中,允许多个方法使用同一个名字,但方法的参数不同,完成的功能也不同。

    对象多态:子类对象可以与父类对象进行转换,而且根据其使用的子类不同完成的功能也不同(重写父类的方法)。

    面试题:什么是多态?实现多态的方法有哪些?

    多态是面向对象的最后一个主要特征,它本身主要分为两个方面:
           ·方法的多态性:重载与覆写
                |-重载:同一个方法名称,根据不同的参数类型及个数可以完成不同的功能。
                |-覆写:同一个方法,根据操作的子类不同,所完成的功能也不同。
           ·对象的多态:父子类对象的转换。
                |-向上转型:子类对象变为父类对象,格式:父类 父类对象 = 子类实例,自动;
                |-向下转型:父类对象变为子类对象,格式:子类 子类对象 = (子类)父类实例,强制。

    多态的优点

    • 1. 消除类型之间的耦合关系
    • 2. 可替换性
    • 3. 可扩充性
    • 4. 接口性
    • 5. 灵活性
    • 6. 简化性

    多态存在的三个必要条件

    • 继承
    • 重写
    • 父类引用指向子类对象

    比如:Parent p = new Child();

    多态的访问方式:
    (1)成员变量
        编译看左边,运行看左边
    (2)成员方法
        编译看左边,运行看右边
    (3)静态方法
        编译看左边,运行看左边

    多态的实现方式

    方式一:重载与重写:

    这个内容已经详细讲过,就不再阐述,详细请见上文。

    方式二:抽象类和抽象方法

    在Java中,一个没有方法体的方法称为抽象方法。而一个类中如果有抽象方法,那么这个类就称之为抽象类。

    格式:
        抽象类:abstract class 类名{}
        抽象方法:修饰符 abstract 返回值类型 方法名(参数列表){方法体;}

    特点:
        1)抽象类不一定有抽象方法,但是有抽象方法的类一定是抽象类
        2)抽象类不可以实例化(不能用new关键字创建抽象类实例)
        3)抽象类的子类,可以是抽象类,也可以是具体类。如果子类是具体类,需要重写抽象类里面所有抽象方法

    组成:
        1)成员变量
            可以是变量,可以是常量
        2)构造方法
            有构造方法
            抽象类不可以实例化,存在构造方法,有什么用?
            子类会调用父类的构造方法,对属性进行初始化赋值
        3)成员方法
            可以是抽象方法,也可以是具体方法

    抽象(abstract)不能与那些关键字共存?
    1).private :因为一个abstract方法需要被重写,所以不能修饰为private;
    2).final:因为一个abstract方法需要被重写。被final修饰的方法是不能被重写的,所以不能同final共存;
    3).static:因为一个abstract方法没有方法体。静态方法需要对方法体执行内容分配空间,所以不能同static共存;(abstract是没有实现  的,不能产生对象,而是static是属于类的,类本身是已经存在的对象)
    4).synchronized: 是同步的,然而同步需要具体的操作才能同步,但, abstract是只有声明没有实现的(即,使用synchronized关键字的是需要有具体的实现同步的操作的,但是使用abstract是只有声明而没有实现的,这样就产生了冲突)
    5).native:他们本身的定义就是冲突的,native声明的方法是移交本地操作系统实现的,而abstract是移交子类对象实现的,同时修饰的话,导致不知道谁实现声明的方法

    方式三:接口

    接口(英文:Interface),在JAVA编程语言中是一个抽象类型,是抽象方法的集合,接口通常以interface来声明。实际上是一个规范,它会要求你做什么,但不会要求你去怎么做。接口里面定义的是额外功能,但是不给出具体的实现。

    接口无法被实例化,但是可以被实现。一个实现接口的类,必须实现接口内所描述的所有方法,否则就必须声明为抽象类。

    接口与类相似点:

    • 一个接口可以有多个方法。
    • 接口文件保存在 .java 结尾的文件中,文件名使用接口名。
    • 接口的字节码文件保存在 .class 结尾的文件中。
    • 接口相应的字节码文件必须在与包名称相匹配的目录结构中。

    接口与类的区别:

    • 接口不能用于实例化对象。
    • 接口没有构造方法。
    • 接口中所有的方法必须是抽象方法。
    • 接口不能包含成员变量,除了 static 和 final 变量。
    • 接口不是被类继承了,而是要被类实现。
    • 接口支持多继承。

    接口特性:

    • 接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract(只能是 public abstract,其他修饰符都会报错)。
    • 接口中可以含有变量,但是接口中的变量会被隐式的指定为 public static final 变量(并且只能是 public,用 private 修饰会报编译错误)。
    • 接口中的方法是不能在接口中实现的,只能由实现接口的类来实现接口中的方法。

    抽象类和接口的区别:

    • 1. 抽象类中的方法可以有方法体,就是能实现方法的具体功能,但是接口中的方法不行。
    • 2. 抽象类中的成员变量可以是各种类型的,而接口中的成员变量只能是 public static final 类型的。
    • 3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法),而抽象类是可以有静态代码块和静态方法。
    • 4. 一个类只能继承一个抽象类,而一个类却可以实现多个接口。

    接口的多继承

    接口和接口继承关系,可以单继承,多继承,多级继承

    标记接口

    标记接口是没有任何方法和属性的接口.它仅仅表明它的类属于一个特定的类型,供其他代码来测试允许做一些事情。

    Java中的标记接口有:

    1. java.io.Serializable这个接口是用来标记类是否支持序列化的,所谓的序列化就是将对象的各种信息转换成可以存储或者传输的一种形式。如果一个类没有实现该接口,却被拿去序列化的了,那么虚拟机就会抛出不支持序列化的异常
    2. Cloneable接口在深度拷贝的时候经常被用到,在调用java.lang.Object类中clone方法的过程中,如果对象没有实现Cloneable接口,那么虚拟机就会抛出一个CloneNotSupportedException异常。
    3. java.util.RandomAccess这个接口的作用是判断集合是否能快速访问,也就是通过索引下标能否快速的移动到对应的元素上。我们在使用某个集合类中,集合中的元素可以通过索引index下标快速的访问到,那么在该类的定义处,一般会有一个RandomAccess接口的实现标签。

      比如:java.util.ArrayList<E>有这个接口,java.util.LinkedList<E>就没有

      1 public class ArrayList<E> extends AbstractList<E>
      2         implements List<E>, RandomAccess, Cloneable, java.io.Serializable
      3 {
      4 //...
      5 }
      1 public class LinkedList<E>
      2     extends AbstractSequentialList<E>
      3     implements List<E>, Deque<E>, Cloneable, java.io.Serializable
      4 {
      5     ...
      6 }

    2、数组的使用以及初始化操作

    数组是用来存储多个相同数据类型值的容器。

    数组初始化
    1)动态初始化
        只指定数组的长度,由系统分配默认值
        格式:
        数据类型[] 数组名 = new 数据类型[长度];     或者      数据类型 数组名[] = new 数据类型[长度]
        默认值:
        byte、short、int、long,默认0
        float、double,默认0.0
        boolean,默认false
        char,默认'\u0000'
        String,默认null(所有引用数据类型默认都是null)
    2)静态初始化
        指定数组里面每个元素的初始值,不指定数组的长度
        格式:
            数据类型[] 数组名 = new 数据类型[]{元素1,元素2...};
        简写:
            数据类型[] 数组名 = {元素1,元素2...};

    简单实例:

    public static void main(String[] args) {
    		  double[] myList = {1.9, 2.9, 3.4, 3.5};
    		  
    	      // 打印所有数组元素
    	      for (int i = 0; i < myList.length; i++) {
    	         System.out.print(myList[i] + " ");
    	      }
    	      System.out.println("\n=================");
    	      for (double d : myList) {
    			System.out.print(d + " ");
    		}
    	      System.out.println("\n=================");
    	      // 计算所有元素的总和
    	      double total = 0;
    	      for (int i = 0; i < myList.length; i++) {
    	         total += myList[i];
    	      }
    	      System.out.println("Total is " + total);
    	      // 查找最大元素
    	      double max = myList[0];
    	      for (int i = 1; i < myList.length; i++) {
    	         if (myList[i] > max) max = myList[i];
    	      }
    	      System.out.println("Max is " + max);
    	}
    
    
    运行结果:
    1.9 2.9 3.4 3.5 
    =================
    1.9 2.9 3.4 3.5 
    =================
    Total is 11.7
    Max is 3.5
    

     冒泡排序(相邻的元素进行比较,大值往后排):

    	public static void bubbleSort(int[] arr){
    		int temp = 0;
    		for (int i = 0; i < arr.length-1; i++) {
    			for (int j = 0; j < arr.length-1-i; j++) {
    				if(arr[j]>arr[j+1]){
    					temp = arr[j];
    					arr[j] = arr[j+1];
    					arr[j+1] = temp;
    				}
    			}
    		}
    	}

     选择排序(前面元素与后面的元素诸葛逐个进行比较,小值往前排):

    	public static void selectSort(int[] arr){
    		int temp = 0;
    		for (int i = 0; i < arr.length-1; i++) {
    			for (int j = i+1; j < arr.length; j++) {
    				if(arr[i]>arr[j]){
    					temp = arr[i];
    					arr[i] = arr[j];
    					arr[j] = temp;
    				}
    			}
    		}
    		System.out.println(Arrays.toString(arr));
    	}

     多维数组

    多维数组可以看成是数组的数组,比如二维数组就是一个特殊的一维数组,其每一个元素都是一个一维数组,例如:

    String str[][] = new String[3][4];

    多维数组初始化的方式与一维数组初始化方式类似,也分动态和静态两种方式。

    不规则数组

    “ 不规则 ” 数组 , 即数组的每一行有不同的长度。典型的案例是杨辉三角

    //不规则数组,杨辉三角
    public class LotteryArray {
    	public static void main(String[] args) {
    		final int NMAX = 10; //最大行数
    		int[][] odds = new int[NMAX][];
    		for (int n = 0; n < NMAX; n++)
    			odds[n] = new int[n + 1]; //初始化,开辟空间
    		for (int n = 0; n < odds.length; n++) {
    			for (int k = 0; k < odds[n].length; k++) {
    				/*
    				 * int lotteryOdds = 1;
    				 * for (int i = 1; i <= k; i++) 
                                     *     lotteryOdds = lotteryOdds * (n - i + 1) / i;
    				 * odds[n][k] = lotteryOdds;
    				 */
    				// 第一个和最有一个都是1,其余的都是它的上一个和它的上一个的前一个的和
    				if (k == 0 || k == odds[n].length - 1) {
    					odds[n][k] = 1;
    				} else {
    					odds[n][k] = odds[n - 1][k - 1] + odds[n - 1][k];
    				}
    
    			}
    		}
    		for (int[] row : odds) {
    			for (int odd : row)
    				System.out.printf("%4d", odd);
    			System.out.println();
    		}
    
    	}
    }
    
    
    =======================结果显示============================
       1
       1   1
       1   2   1
       1   3   3   1
       1   4   6   4   1
       1   5  10  10   5   1
       1   6  15  20  15   6   1
       1   7  21  35  35  21   7   1
       1   8  28  56  70  56  28   8   1
       1   9  36  84 126 126  84  36   9   1

    数组工具类Arrays

    修饰符和类型 方法和描述
    static <T> List<T>

    asList(T... a)

    返回由指定数组支持的固定大小的列表。

    static int

    binarySearch(byte[] a, byte key)

    使用二进制搜索算法在指定的字节数组中搜索指定的值。

    static int

    binarySearch(byte[] a, int fromIndex, int toIndex, byte key)

    使用二进制搜索算法搜索指定值的指定字节数组的范围。

    char[]、double[]、float[]、int[]、long[]、Object[]、short[]...同样适用

    static boolean[]

    copyOf(boolean[] original, int newLength)

    使用false复制指定的数组,截断或填充(如果需要),以使副本具有指定的长度。

    static byte[]

    copyOf(byte[] original, int newLength)

    使用零复制指定的数组,截断或填充(如有必要),以使副本具有指定的长度。

    char[]、double[]、float[]、int[]、long[]...同样适用

    static char[]

    copyOfRange(boolean[] original, int from, int to)

    将指定数组的指定范围复制到新数组中。

    static double[]

    copyOfRange(boolean[] original, int from, int to)

    将指定数组的指定范围复制到新数组中。

    boolean[]、char[]、float[]、int[]、long[]同样

    static boolean equals(boolean[] a, boolean[] a2)

    如果两个指定的布尔数组彼此相等,则 返回true。

    byte[]、char[]、double[]...同样适用

    static void fill(boolean[] a, boolean val)

    将指定的布尔值分配给指定的布尔数组的每个元素。

    byte[]、char[]、double[]...同样适用

    static void parallelSort(byte[] a)

    将指定的数组按升序排序。java8新特性,并行排序。

    static void sort(float[] a)

    将指定的数组按升序排序。串行排序。

    static void sort(float[] a, int fromIndex, int toIndex)

    按升序对数组的指定范围进行排序。

    int[]、short[]、long[]、double[]...同样适用

    static String toString(boolean[] a)

    返回指定数组内容的字符串表示形式。

    3、java基本数据类型和引用传递区别

    简概: ①形参为基本数据类型形参改变,实参不会发生改变
     ②形参为引用数据类型形参改变,实参也会跟着改变(有特例)

    详述:https://blog.csdn.net/sugar_no1/article/details/86506510

     

    展开全文
  • 什么是面向对象

    千次阅读 2019-06-03 12:19:33
    面向对象说到底就是一种思想,任何事物都可以看作是一个对象。在有些面试题目中也称之为OOP(Object Oriented Programming)。分开来解读就是: Object:对象、 Oriented: 面向的 Programming:程序设计...

    说到这个面试题目,可以说是老生常谈啦。无论是对于新手还是老手,面对不同时期的程序员,都会有不同的理解,不同的思路。回答的内容深度也会大不相同。

    面向对象说到底就是一种思想,任何事物都可以看作是一个对象。在有些面试题目中也称之为OOP(Object Oriented Programming)。分开来解读就是:

    Object:对象、

    Oriented: 面向的

    Programming:程序设计

    那么这篇文章就以为java为例子,java是一个支持并发,基于类和面向对象的计算机语言,面向对象的开发具有以下的有点:

    • 代码开发模块化,便于维护。
    • 代码复用性强
    • 代码的可靠性和灵活性。
    • 代码的可读性和可扩展性。

    其实上面的还都是铺垫,面向对象主要的思想是:封装,继承,多态,抽象。

    封装

    封装就是模块化,把不同的功能,封装在不同的模块里。一个好的设计,应该有好的封装思路。这个不属于框架设计里了,属于编程人员对于功能的把握。以及对于封装的理解。

    切记,如果随意进行封装,太注重模块的封装,每一个小功能都封装成一个模块,那么对于日后的维护,会造成非常大的困扰。我曾经有位离职的同事,我交接了他的代码。他的代码优点是封装的很完全,但是缺点也是封装的太完全了。一点小的功能都封装起来,一个小方法写了6行左右,就跑到另外一个方法里了。给维护造成了非常的困扰。(当时我想打si他)

    但是不能因为封装可能出现上述的原因,就不封装了。比如一个相似的功能,你把他写在统一个方法里,不进行封装,那么,你每次进行修改了这个方法后,你都要提心吊胆,是否会影响其他的功能,测试人员,还要根据你的感觉,去测试其他的功能,无形中给自己和别人都添加了麻烦。

    在java中提供了4中修饰符,来实现封装。分别是default,public,private和protected。每一种修饰符都表示了不同的权限。就因为有了这四种修饰符:

    • 通过隐藏对象的内部结构,提高了程序的安全性。
    • 禁止对象之间的不良引用

    另外给出一个图帮助大家理解这4个修饰符

    作用域 当前类 同包 子类 其他
    private 支持 不支持 不支持 不支持
    default 支持 支持 不支持 不支持
    protected 支持 支持 支持 不支持
    public  支持 支持 支持 支持

    至于使用的场景嘛?

    public:更多得在写公共方法会使用到。

    private:在类中有些私有得方法会用到但是比较少,一般是在变量私有,使用get,set方法时,会配合public一起使用。

    default:在不写修饰符得情况下,默认为default修饰符。另外有个特殊的点,就是接口的方法不写修饰符,默认是public。而不是default

    protected:保护,更多得是用于框架层啦,就是子类得引用支持,像封装了struts。在controller层就必须继承某一个类一样。

    继承

    继承嘛,就简单很多了,就是给对象提供了从基类获取字段和方法得能力,java中提供了extends关键字。好处是在不修改原类得情况下,给现存得类添加新特性。对于程序得升级给了很大得思路。多态

    多态

    多态,相当于对于同一个接口类型,由多种不同的实现方式,所衍生出来的。

    抽象

    抽象,相当于把具体的实例中,把本质抽象出来。把行为和具体的实现进行分离开来,对于程序的保密起到一定的作用把。

     

     

    展开全文
  • 面向对象的概念介绍

    万次阅读 多人点赞 2018-08-24 09:02:18
    这一篇主要是介绍面向对象的各种概念性的东西,并不会说具体的代码怎样写,所以可以用一种轻松的心态去看。 一、面向过程和面向对象 面向对象是相对于面向过程的一种编程方式。 面向过程的编程方式由来已久,我刚...
  • 面向对象 面向对象的基本概念 面向对象程序设计 继承成员访问控制机制: 面向对象分析与设计方法 设计模式
  • 面向对象和面向过程

    千次阅读 多人点赞 2019-03-07 22:19:30
    什么是面向对象? 如果面试的时候问面向对象和面向过程的区别,就用Action、Service、 Dao去答。 1.什么是面向过程 仔细思考一下,我们在学习和工作中,当我们去实现某项功能或 完成某项任务时,是不是会...
  • 面向对象——(封装)

    万次阅读 多人点赞 2018-07-22 15:55:11
    面向对象的概念:  理解面向对象:  面向对象是相对于面向的过程而言的。  面向过程和面向对象都是强调的一种思想。  面向过程:强调的是功能的行为。  面向对象:把功能封装进对象,强调具备了功能的对象...
  • 面向对象与面向过程的本质的区别

    万次阅读 多人点赞 2020-04-25 22:31:38
    如果你很想搞明白面向对象是什么,面向过程是什么,或者说二者之间的区别是什么,那么就花费一点时间来研读一下这篇博客,你一定会有很大的收获的! 一、面向对象与面向过程的区别 面向过程就是分析出解决问题所...
  • 面向对象与面向过程语言的区别

    万次阅读 多人点赞 2017-10-24 16:09:22
    计算机语言可以归为面向过程语言和面向对象语言,那么到底什么是面向对象,什么是面向过程呢? 答:面向过程就是分析出解决问题所需要的步骤,然后用函数把这些步骤一步一步实现,使用的时候一个一个依次调用就可以...
  • 面试总结之谈谈你对面向对象的理解

    万次阅读 多人点赞 2017-09-27 12:17:05
    面向对象的理解 在我理解,面向对象是向现实世界模型的自然延伸,这是一种“万物皆对象”的编程思想。在现实生活中的任何物体都可以归为一类事物,而每一个个体都是一类事物的实例。面向对象的编程是以对象为...
  • 在计算机科学中,对象(英语:object),台湾译作物件,是一个存储器地址,...是面向对象(Object Oriented)中的术语,既表示客观世界问题空间(Namespace)中的某个具体的事物,又表示软件系统解空间中的基本元素。
  • 面向对象和面向过程的区别

    万次阅读 2010-01-30 10:49:00
    简单的说吧:对象就是类,而过程呢就是顺序,选择,循环,数组,函数:面向对象是以数据为中心,而面向过程以功能为中心 总体而言,面向过程就是分析出解决问题所需要的步骤,然后用函数把这些问题一步一步的实现,...
  • 今天从同事那儿听到一句话,“java不同于javascript,Java是面向对象的”。言下之意,难不成javascript是面向过程? 虽然javascript一直容易被人长期误解,但其确确实实的是面向对象的编程语言。 很多人可能觉得...
  • 什么是面向对象思想

    万次阅读 多人点赞 2017-02-07 16:07:21
    面向对象是一种思想,是基于面向过程而言的,就是说面向对象是将功能等通过对象来实现,将功能封装进对象之中,让对象去实现具体的细节;这种思想是将数据作为第一位,而方法或者说是算法作为其次,这是对数据一种...
  • 面向过程与面向对象的区别

    万次阅读 2019-06-04 15:36:12
    面向对象: 当需要实现一个功能的时候,我们不需要自己去做,可以直接找一个已经具有该功能的东西,来帮我解决问题。 eg:吃饭 面向过程:买菜-洗菜-做菜-装盘-吃 面向对象:去饭店-吃 区别: 面向过程强调的是步骤...
  • 请说明一下你对面向对象的理解

    万次阅读 多人点赞 2012-10-21 17:31:00
     面向对象是基于万物皆对象这个哲学观点. 把一个对象抽象成类,具体上就是把一个对象的静态特征和动态特征抽象成属性和方法,也就是把一类事物的算法和数据结构封装在一个类之中,程序就是多个对象和互相之间的通信...
  • 面向对象分析的三个模型与5个层次

    万次阅读 2017-03-11 17:13:46
    面向对象分析中,主要由对象模型、动态模型和功能模型组成。对象模型是最基本、最重要、最核心的。 面向对象建模得到的模型包含系统的3个要素,即静态结构(对象模型)、交互次序(动态模型)和数据变换(功能模型)...
  • 面向对象开发软件——三种模型

    万次阅读 2007-11-03 17:29:00
    面向对象方法开发软件,通常需要建立三种形式的模型:对象模型:描述系统数据结构动态模型:描述系统控制结构功能模型:描述系统功能 什么是对象模型对象模型表示静态的、结构化的系统的“数据”性质。对象模型是...
  • 封装:是指将事物 的特征和行为抽象为一个类。...多态:是指对于相同的调用或操作,作用于不同的对象,而导致其行为也不同,它增强了软件的灵活性和重要性 有问题咨询老师微信,微信号:mikeshizhanbiao
1 2 3 4 5 ... 20
收藏数 982,976
精华内容 393,190
关键字:

面向对象