精华内容
下载资源
问答
  • 对象化思维
    千次阅读
    2019-06-03 21:30:56

    1.结构化方法遵循的基本原则
    结构化方法的基本思想就是将待解决的问题看作一个系统从而用系统科学的思想方法来分析和解决问题结构化方法遵循以下基本原则
    (1)抽象原则
    抽象原则是一切系统科学方法都必须遵循的基本原则它注重把握系统的本质内容而忽略与系统当前目标无关的内容它是一种基本的认知过程和思维方式
    (2)分解原则
    分解原则是结构化方法中最基本的原则它是一种先总体后局部的思想原则在构造信息系统模型时它采用自顶向下分层解决的方法
    (3)模块化原则
    模块化是结构化方法最基本的分解原则的具体应用它主要出现在结构化设计阶段中其目标是将系统分解成具有特定功能的若干模块从而完成系统指定的各项功能
    2.面向对象模型遵循的基本原则
    面向对象模型遵循的基本原则有:抽象、封装、模块化以及层次原则等
    (1)抽象
    抽象是处理现实世界复杂性的最基本方式在OO方法中它强调一个对象和其他对象相区别的本质特性对于一个给定的域确定合理的抽象集是面向对象建模的关键问题之一
    (2)封装
    封装是对抽象元素的划分过程抽象由结构和行为组成封装用来分离抽象的原始接口和它的执行
    封装也称为信息隐藏Information Hiding它将一个对象的外部特征和内部的执行细节分割开来并将后者对其他对象隐藏起来
    (3)模块化
    模块化是已经被分为一系列聚集的和耦合的模块的系统特性对于一个给定的问题确定正确的模块集几乎与确定正确的抽象集一样困难通常每个模块应该足够简单以便能够被完整地理解
    (4)层次
    抽象集通常形成一个层次,层次是对抽象的归类和排序。在复杂的现实世界中有两种非常重要的层次一个是类型层次另一个是结构性层次 。确定抽象的层次是基于对象的继承,它有助于在对象的继承中发现抽象间的关系,搞清问题的所在理解问题的本质
    3.结构化方法的核心问题
    模型问题是结构化方法的核心问题建立模型简称建模是为了更好地理解我们要模拟的现实世界建模通常是从系统的需求分析开始在结构化方法中就是使用SA方法构建系统的环境模型然后使用SD方法确定系统的行为和功能模型最后使用SP方法进行系统的设计并确定用户的现实模型
    4..面向对象方法的核心问题
    面向对象方法与结构化方法一样其核心问题也是模型问题面向对象模型主要由OOA模型OOD模型组成其中OOA主要属于学科抽象形态方面的内容OOD主要属于学科设计形态方面的内容

    5.结构化系统分析方法的特点
    (1)面向用户,用户自始至终参与系统的分析工作;
    (2)强调调查工作的重要性;
    (3)对管理业务中的各种数据进行分解;
    (4)采用了层次分解的系统思想;
    (5)用图形工具来分析和构建新方案。
    ¨结构化分析的图表工具主要由数据流程图、数据字典和数据处理说明组成。
    6.面向对象系统分析方法的特点
    (1)      强调系统开发的整体性和全局性
    (2)      侧重于数据转换的过程而不是数据本身
    (3)      系统的开发周期长
    (4)      封装性 
    对象的概念突破了传统数据与操作分离的模式。对象作为独立存在的实体,将自由数据和操作封闭在一起,使自身的状态、行为局部化。
    (5)     继承性 
    继承是面向对象特有的,亦是最有力的机制。通过类继承可以弥补由封装对象而带来的诸如数据或操作冗余的问题,通过继承支持重用,实现软件资源共享、演化以及增强扩充。
    (6)     多态性 
    同一消息发送至不同类或对象可引起不同的操作,使软件开发设计更便利,编码更灵活。
    (7)     易维护性
    面向对象的抽象封装使对象信息隐藏在局部。当对象进行修改,或对象自身产生错误的时候,由此带来的影响仅仅局限在对象内部而不会波及其他对象乃至整个系统环境,这极大方便了软件设计、构造和运行过程中的检错、修改。
     

    更多相关内容
  • 面向对象的思维(与结构化思维比较)

    千次阅读 2016-06-22 09:28:29
    一、综述  在计算机科学中,对象(Object)通常是问题域或实现域中某些事物的一个抽象,它反映此事物...使用该对象的用户也不需要知道对象中具体的数据和程序情况,只需要了解该对象的接口,及接收什么样的消息和会

    一、综述

           在计算机科学中,对象(Object)通常是问题域或实现域中某些事物的一个抽象,它反映此事物在系统中需要保存的信息和发挥的作用;它是一组属性和有权对这些属性进行操作的一组服务的封装体。对象是一个黑盒子,他是用来接收和发送消息;一个对象实体中,通常包括有数据和程序两部分。使用该对象的用户也不需要知道对象中具体的数据和程序情况,只需要了解该对象的接口,及接收什么样的消息和会反馈什么就可以了。


    那么,到底什么是面面对象呢?从本质上说,面向对象既是一种思想,也是一种技术,它是过程式程序设计方法的一个高级层次。面向对象思想利用对问题的高度抽象来提升代码的可重用性,从而提高生产力。尤其是在较为复杂的规模较大的系统实现中,面向对象通常比传统的过程式方法产生更高的效能。而且,随着软件规模的增大,面向对象相对于传统的过程式的优势就更加凸现。可以说,是软件产业化最终促进了面向对象技术的产生和发展。

    面向对象有三大基本机制:封装、继承、多态,称一个编程或程序构建是面向对象的,首先他要具有这几个特点。在面向对象的编程和设计中,以类和对象来刻画客观世界。面向对象技术就是针对现实思维方式而产生的,继承和抽象,归纳和演绎是面向对象技术中常用的方法学和思维模式。面向对象技术是一种按照人们对现实世界习惯的认识论和思维方式来研究和模拟客观世界的方法学。

    “Why all this concern for being able to change software? Because experience has taught 

    us that software changes. A popular adage is that "software is not written, 

    it is re-written".”

    二、面向对象的相关概念

    1、对象:是人们要进行研究的事物,从最简单的整数到复杂的飞机等均可看作对象,它不仅能表示具体的事物,还能表示抽象的规则、计划或事件。

    2、类:具有相同或相似性质的对象的抽象就是类。类中操作的实现过程叫做方法。对象之间进行通信的结构叫做消息。

    3、抽象:抽象是从众多的事物中抽取出共同的、本质性的特征,而舍弃其非本质的特征。例如苹果、香蕉、生梨、葡萄、桃子等,它们共同的特性就是水果。得出水果概念的过程,就是一个抽象的过程。要抽象,就必须进行比较。抽象化主要是为了使复杂度降低,以得到论域中较简单的概念,好让人们能够控制其过程或以综观的角度来了解许多特定的事态。

    4、思维:思维是人脑对客观事物的本质属性和事物之间内在联系的规律性所作出的概括与间接的反映。抽象思维凭借科学的抽象概念对事物的本质和客观世界发展的深远过程进行反映,使人们通过认识活动获得远远超出靠感觉器官直接感知的知识。科学的抽象是在概念中反映自然界或社会物质过程的内在本质的思想,它是在对事物的本质属性进行分析、综合、比较的基础上,抽取出事物的本质属性,撇开其非本质属性,使认识从感性的具体进入抽象的规定,形成概念。科学的、合乎逻辑的抽象思维是在社会实践的基础上形成的。思维是建立在人们对现存事物的充分认识基础之上,经过大脑对这些现存事物的感性认识、理解、分析、总结等逻辑思考过程,从而对其本质属性做出内在的、联系的、间接的、概括的反映;而设计则是通过一定的手段创造性地改变这些事物的性质,形成可以具备价值的物品的活动。

    5、多态性:多态性就是多种表现形式,即同样的消息被不同的对象所接受将会产生不同的结果。当然,也有"一个对外接口,多个内在实现方法"的情况。举一个例子,计算机中的堆栈可以存储各种格式的数据,包括整型,浮点或字符。不管存储的是何种数据,堆栈的算法实现是一样的。针对不同的数据类型,编程人员不必手工选择,只需使用统一接口名,系统可自动选择。

    6、封装:封装就是将抽象得到的数据和行为(或功能)相结合,形成一个有机的整体,即将数据与操作数据的源代码进行有机的结合,形成“类”,其中数据和函数都是类的成员。封装的目的是增强安全性和简化编程,使用者不必了解具体的实现细节,而只是要通过外部接口,一特定的访问权限来使用类的成员。

    7、继承:继承是指一个对象直接使用另一对象的属性和方法。其本质是从现在的类生成新类。继承关系是静态关系。包括静态继承和动态继承;静态继承是在父类的基础上通过增加数据成员和方法成员而构成子类的过程,而动态继承是以父类的实例作为子类的数据成员而存在的一种方法。动态继承是传统意义上的组合,或称为聚合,类似于C语言中的结构体成员是结构变量。静态继承中的父类和子类之间是一种泛化-特化的关系,动态继承中的父类和子类之间是一种整体-部分的关系。

    8、重载:在一个类定义中,可以编写几个同名的方法,但是只要它们的签名参数列表不同。重载只是一种语言特性,与多态无关,与面向对象也无关。

    9、覆盖:覆盖是指子类重新定义父类的虚函数。

    10、归纳:从许多个别的事物中概括出一般性概念,原则,或结论的思维方法。

    11、演绎:从普遍性结论或一般性事理推导出个别性结论的论证方法。

    12、泛化:当某一反应与某种刺激形成条件联系后,这一反应也会与其它类似的刺激形成某种程度的条件联系,这一过程称为泛化,即模板化。

    13、特化:将模板对应于某一特定类型进行特别的声明或定义。

    14、聚合:是关联的一种形式,代表两个类之间的整体和局部关系。聚合暗示着整体在概念上处于比局部更高的一个级别,而关联暗示两个类在概念上位于相同的级别。

    15、接口:在C++中,一个类被允许继承多个类。但是在Java以后的语言不被允许。这样,如果想继承多个类时便非常困难。所以开发方想出了新办法:接口。一个接口内,允许包含变量、常量等一个类所包含的基本内容。但是,接口中的函数不允许设定代码,也就意味着不能把程序入口放到接口里。由上可以理解到,接口是专门被继承的。接口存在的意义也是被继承。和C++里的抽象类里的纯虚函数类似,不能被实例化。

    16、复用:复用就是指“利用现成的东西”。把复用的思想用于软件开发,称为软件复用。

    17、构件:是一个物理的、可替换的系统组成部分,它包装了实现体且提供了对一组接口的实现方法。是面向软件体系结构的可复用软件模块。未来软件开发的过程就是构件组装的过程,维护的过程就是构件升级、替换和扩充的过程。其优点是构件组装模型导致了软件的复用,提高了软件开发的效率。

    18、面向对象设计的准则:模块化、抽象、信息隐藏、低耦合、高内聚。面向对象的三特点:封装、继承、多态。面向对象的三大要素:抽象、封装性(信息隐藏)、共享性。

    19、方法:指人们为了达到某种目的而采取的手段、途径和行为方式中所包含的可操作的规则或模式。



    2.1 方法背景

    结构化思想和面向对象思想虽都产生于20世纪60年代,但它们却存在根本差别。结构化方法承袭了传统的编程思想与编程方法,以计算机的计算功能为前提。编写程序的主要目的是数值计算、问题求解。模块是结构化编程的基本单位,但计算方法(简称为算法)是程序的核心。沃尔森曾提出了一个著名公式:程序=算法+数据结构。结构化方法只是对传统程序结构的改进,用三种基本结构来组织程序,使程序结构更为清晰,程序开发更有序、更容易。

    面向对象思想则以计算机信息处理和信息管理的功能为前提,模拟客观世界的事物及事物之间的联系。对象技术的关键概念是对象、消息、类,关键机制包括封装、多态和继承。与结构化方法相比,对象是软件模块化的一种新的单位,它代替了基于功能分解方法中的所谓“模块”等传统的技术。面向对象技术是通过对对象的管理(创建、运行、消亡)以及对象之间的通讯来实现程序功能。结构化方法中模块只是程序一个功能(机械)部件,在程序中完成特定功能或解决特定问题。因此程序中模块通常用函数(function)来实现,完成对输人数据的加工和计算。而面向对象中的对象则是一个活体(生命体),它将数据和过程封装在一起,这同传统的方法中将数据和过程分别对待和处理形成了鲜明的对比。对象代表现实世界中真实对象的结构和交互作用,在程序运行期间有它的生命周期,并通过消息相互通信协同完成程序功能。

    2.2 分析问题的方法

    软件分析是软件工程的一个重要阶段。在软件分析阶段,主要确定待开发软件的功能、性能和运行环境约束;同时提出解决问题或实现功能的方法和途径,化解一个系统的复杂性,通常有两种解决方法。化解复杂性的最基本技术是将一个大问题分解为一些容易解决的小问题,待小问题解决了大问题也就解决了。结构化分析方法的核心思想是:自顶向下,逐层分解,逐步求精。结构化分析方法体现在数据流图和系统结构图的分解过程中。数据流图的分解从顶层图开始,按照每个加工对应一个子图的分解原则,逐层分解为0层图、1层图等。系统结构图则是从主模块开始,逐层分解为算法更为简单、更加容易管理和实现的子模块。

    面向对象分析则是采用了另一种自底向上的化解复杂性的方法:抽象。通过抽象,得到系统的一个简化模型,其中强调系统中某属性细节,而忽略其它的属性。面向对象分析存在三个层次的抽象:第一,识别对象及其属性和方法,这是客观世界事物的抽象;第二,对对象进行层层归类,对客观事物相互关系的抽象,如把相似对象归为一类,或把子类归到父类,或把局部类归整体类;第三,将对象和类进一步抽象归到某个主题,便于对类和对象的定义和管理。结构化分析方法承袭了传统数学问题求解的思想,采用了逐步求精的数学演绎方法,有利于数据的加工、计算等问题的解决。但逐步求精的方法不能提供解决一个具体问题的系统的策略或方法。有时,对于某些问题不存在一个自顶向下的方法。结构化程序分析方法对小规模的程序是一种有效的方法,但将它推广至大规模的系统开发中往往会失效,开发人员无法使用这一方法来很方便地重用以前程序的可重用成份。面向对象方法的抽象机制提供了为复杂的软件系统建模更为自然的方法,特别是能很好地把握对象之间复杂的相互关系,因此面向对象分析技术更加适用于复杂的软件系统的分析。

    2.3 程序设计方法

    结构化程序设计方法与分析方法思路相反,采用了自底向上的设计思想。首先设计底层模块,确定模块内部算法,设计模块内部程序,并进行单元测试。模块完成之后,再进行模块之间的组装,进行集成测试。待模块集成测试完成之后,进行确认测试和系统测试,完成设计和调试任务。

    面向对象程序设计方法采用了自顶向下的设计思想,先设计父类,再设计子类,并继承父类属性和方法。对象是最后在程序运行过程中动态生成。在设计类的同时,另一任务是消息的设计。并将消息与类中的方法有机联系起来,以便对象在运行过程中能相互通信,共同实现软件设定的功能。消息类似于传统程序设计语言中的函数调用,二者的主要区别是函数调用中所执行的函数是一个单一、公共的实现,而对消息的响应可以不同回答,这要根据具体对象的方法来确定。这就是面向对象程序设计思想的多态机制。

    2.4 适用场合

    结构化方法的实质是问题求解,即结构化程序是由算法决定的,而算法是程序员分析设计的。因此结构化方法中,程序的执行过程主要是由程序员控制,而不是由用户控制。该方法比较适合大型工程计算、实时数据的跟踪处理、各种自动控制系统等等。

    面向对象方法中,程序员设计的是对象属性及操作方法,但在什么时间、使用什么方式操作对象则是完全由用户交互控制。在互联网时代,计算机已经由一个生产工具逐步演变成一个生活工具,出现了许多完全由用户控制程序执行过程的应用软件,比如大型游戏软件以及各类管理信息系统软件。这些软件中各种关系比较复杂,适宜使用面向对象的方法来开发。

    2.5 举个例子(转)

    使用面向对象的思维方法进行设计,其实是一个把业务逻辑从具体的编程技术当中抽象出来的过程,而这个抽象的过程是自上而下的,非常符合人类的思维习惯,也就是先不考虑问题解决的细节,把问题的最主要的方面抽象成为一个简单的框架,集中精力思考如何解决主要矛盾,然后在解决问题的过程中,再把问题的细节分割成一个一个小问题,再专门去解决细节问题。而一个合理运用面向对象技术进行设计和架构的软件,更是具备了思维的艺术美感。

    举个例子,要发广告邮件,广告邮件列表存在数据库里面。倘若用C来写的话,一般会这样思考,先把邮件内容读入,然后连接数据库,循环取邮件地址,调用本机的qmail的sendmail命令发送。

    如果考虑面向对象方法来做,就不能什么代码都塞到main过程里面,假设我们设计三个类:

    一个类是负责读取数据库,取邮件地址,调用qmail的sendmail命令发送;

    一个类是读邮件内容,MIME编码成HTML格式的,再加上邮件头;

    一个主类负责从命令读参数,处理命令行参数,调用发email的类。

    把一件工作按照功能划分为3个模块分别处理,每个类完成一件模块任务。

    仔细的分析一下,就会发现这样的设计完全是从程序员实现程序功能的角度来设计的,或者说,设计类的时候,是自低向上的,从机器的角度到现实世界的角度来分析问题的。因此在设计的时候,就已经把程序编程实现的细节都考虑进去了,企图从底层实现程序这样的出发点来达到满足现实世界的软件需求的目标。这样的分析方法其实是不适用于面向对象的编程语言,因为,如果改用C语言,封装两个C函数,都会比Java/C++实现起来轻松的多,逻辑上也清楚的多。面向对象的精髓在于考虑问题的思路是从现实世界的人类思维习惯出发的,只要领会了这一点,就领会了面向对象的思维方法。

    那么应用面向对象的方法就逮怎么做呢?

    对于一个邮件来说,有邮件头,邮件体,和邮件地址这三个属性,发送邮件,需要一个发送的方法,另外还需要一个能把所有邮件地址列出来的方法。所以应该如下设计:

    类 JunkMail

    属性:

    head

    body

    address

    方法:

    sendMail() // 发送邮件

    listAllMail() // 列邮件地址

    这就够了。

    如果说传统的面向过程的编程是符合机器运行指令的流程的话,那么面向对象的思维方法就是符合现实生活中人类解决问题的思维过程。

    在面向对象的软件分析和设计的时候,要提醒自己,不要一上来就去想程序代码的实现,应该抛开具体编程语言的束缚,集中精力分析我们要实现的软件的业务逻辑,分析软件的业务流程,思考应该如何去描述和实现软件的业务。毕竟软件只是一个载体,业务才是我们真正要实现的目标。

    在设计的时候不应过早的考虑具体程序语言的实现,必须用抽象的方法,和具体实现无关的方法来表达业务逻辑。

    展开全文
  • JAVA面向对象思维导图

    千次阅读 2019-08-31 20:05:43
    JAVA面向对像做的一个简单的思维导图:

    JAVA面向对像做的一个简单的思维导图:

    表格结构和类结构我们在现实生活中,思考问题、发现问题、处理问题,往往都会用“表格”作为工具。实际上,“表格思维”就是一种典型的面向对象思维。 实际上,互联网上所有的数据本质上都是“表格”。我们在这里通过从表格表示数据开始,引入对象和类。大家就会神奇的发现,原来“表格就是对象”。
    面向过程和面向对象的区别面向过程和面向对象都是对软件分析、设计和开发的一种思想,它指导着人们以不同的方式去分析、设计和开发软件。早期先有面向过程思想,随着软件规模的扩大,问题复杂性的提高,面向过程的弊端越来越明显的显示出来,出现了面向对象思想并成为目前主流的方式。两者都贯穿于软件分析、设计和开发各个阶段,对应面向对象就分别称为面向对象分析(OOA)、面向对象设计(OOD)和面向对象编程(OOP)。C语言是一种典型的面向过程语言,Java是一种典型的面向对象语言。

    面向对象是一种“设计者思维”。设计时,先从问题中找名词,然后确立这些名词哪些可以作为类,再根据问题需求确定的类的属性和方法,确定类之间的关系。 设计一款企业管理软件,我们需要进行面向对象分析(OOA:Object-Oriented Analysis),写一首诗、一篇文章、一篇小说也需要进行面向对象分析。 因此,面向对象这种思维是任何人都需要学习、任何人都需要掌握的。

    类的定义:做了关于对象的很多介绍,终于进入代码编写阶段。本节中重点介绍类和对象的基本定义,属性和方法的基本使用方式。 属性(field 成员变量)属性用于定义该类或该类对象包含的数据或者说静态特征。属性作用范围是整个类体。在定义成员变量时可以对其初始化,如果不对其初始化,Java使用默认的值对其初始化。
    方法方法用于定义该类或该类实例的行为特征和功能实现。方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中,函数是最基本单位,整个程序由一个个函数调用组成。面向对象中,整个程序的基本单位是类,方法是从属于类和对象的。
    构造方法基础用法构造器也叫构造方法(constructor),用于对象的初始化。构造器是一个创建对象时被自动调用的特殊方法,目的是对象的初始化。构造器的名称应与类的名称一致。Java通过new关键字来调用构造器,从而返回该类的实例,是一种特殊的方法。
    构造方法的重载: 构造方法也是方法,只不过有特殊的作用而已。与普通方法一样,构造方法也可以重载。
    Java虚拟机的内存可以简单的分为三个区域:虚拟机栈stack、堆heap、方法区method area。 虚拟机栈(简称:栈)的特点如下:1. 栈描述的是方法执行的内存模型。每个方法被调用都会创建一个栈帧(存储局部变量、操作数、方法出口等)2. JVM为每个线程创建一个栈,用于存放该线程执行方法的信息(实际参数、局部变量等)3. 栈属于线程私有,不能实现线程间的共享!4. 栈的存储特性是“先进后出,后进先出”5. 栈是由系统自动分配,速度快!栈是一个连续的内存空间!堆的特点如下:1. 堆用于存储创建好的对象和数组(数组也是对象)2. JVM只有一个堆,被所有线程共享3. 堆是一个不连续的内存空间,分配灵活,速度慢!方法区(又叫静态区,也是堆)特点如下:1. 方法区是JAVA虚拟机规范,可以有不同的实现。 i. JD7以前是“永久代”ii. JDK7部分去除“永久代”,静态变量、字符串常量池都挪到了堆内存中iii. JDK8是“元数据空间”和堆结合起来。2. JVM只有一个方法区,被所有线程共享!3. 方法区实际也是堆,只是用于存储类、常量相关的信息!4. 用来存放程序中永远是不变或唯一的内容。(类信息【Class对象,反射机制中会重点讲授】、静态变量、字符串常量等)
    ava中,方法中所有参数都是“值传递”,也就是“传递的是值的副本”。 也就是说,我们得到的是“原参数的复印件,而不是原件”。因此,复印件改变不会影响原件。· 基本数据类型参数的传值 传递的是值的副本。 副本改变不会影响原件。· 引用类型参数的传值 传递的是值的副本。但是引用类型指的是“对象的地址”。因此,副本和原参数都指向了同一个“地址”,改变“副本指向地址对象的值,也意味着原参数指向对象的值也发生了改变”。
    this关键字对象创建的过程和this的本质构造方法是创建Java对象的重要途径,通过new关键字调用构造器时,构造器也确实返回该类的对象,但这个对象并不是完全由构造器负责创建。创建一个对象分为如下四步:1. 分配对象空间,并将对象成员变量初始化为0或空2. 执行属性值的显示初始化3. 执行构造方法4. 返回对象的地址给相关的变量 this的本质就是“创建好的对象的地址”! 由于在构造方法调用前,对象已经创建。因此,在构造方法中也可以使用this代表“当前对象” 。 this最常的用法:q 在程序中产生二义性之处,应使用this来指明当前对象;普通方法中,this总是指向调用该方法的对象。构造方法中,this总是指向正要初始化的对象。q 使用this关键字调用重载的构造方法,避免相同的初始化代码。但只能在构造方法中用,并且必须位于构造方法的第一句。q this不能用于static方法中。
    static 关键字在类中,用static声明的成员变量为静态成员变量,也称为类变量。 类变量的生命周期和类相同,在整个应用程序执行期间都有效。它有如下特点:q 为该类的公用变量,属于类,被该类的所有实例共享,在类被载入时被显式初始化。q 对于该类的所有对象来说,static成员变量只有一份。被该类的所有对象共享!!q 一般用“类名.类属性/方法”来调用。(也可以通过对象引用或类名(不需要实例化)访问静态成员。)q 在static方法中不可直接访问非static的成员。
    包机制(package、import)包机制是Java中管理类的重要手段。 开发中,我们会遇到大量同名的类,通过包我们很容易对解决类重名的问题,也可以实现对类的有效管理。 包对于类,相当于文件夹对于文件的作用。package我们通过package实现对类的管理,package的使用有两个要点:1. 通常是类的第一句非注释性语句。2. 包名:域名倒着写即可,再加上模块名,便于内部管理类。
    继承 继承是面向对象编程的三大特征之一,它让我们更加容易实现对于已有类的扩展、更加容易实现对于现实世界的建模。继承有两个主要作用:1. 代码复用,更加容易实现类的扩展2. 方便对事务建模
    继承的实现继承让我们更加容易实现类的扩展。
    继承使用要点1. 父类也称作超类、基类。子类:派生类等。2. Java中只有单继承,没有像C++那样的多继承。多继承会引起混乱,使得继承链过于复杂,系统难于维护。3. Java中类没有多继承,接口有多继承。 4. 子类继承父类,可以得到父类的全部属性和方法 (除了父类的构造方法),但不见得可以直接访问(比如,父类私有的属性和方法)。5. 如果定义一个类时,没有调用extends,则它的父类是:java.lang.Object。
    final关键字final关键字的作用:q 修饰变量: 被他修饰的变量不可改变。一旦赋了初值,就不能被重新赋值。final int MAX_SPEED = 120;q 修饰方法:该方法不可被子类重写。但是可以被重载!final void study(){}q 修饰类: 修饰的类不能被继承。比如:Math、String等。final class A {}
    继承和组合我们可以通过继承方便的复用已经定义类的代码。还有一种方式,也可以方便的实现“代码复用”,那就是:“组合”。 “组合”不同于继承,更加灵活。“组合”的核心就是“将父类对象作为子类的属性”,然后,“子类通过调用这个属性来获得父类的属性和方法”。
    super关键字super“可以看做”是直接父类对象的引用。可以通过super来访问父类中被子类覆盖的方法或属性。使用super调用普通方法,语句没有位置限制,可以在子类中随便调用。
    继承树追溯·属性/方法查找顺序:(比如:查找变量h)q 查找当前类中有没有属性hq 依次上溯每个父类,查看每个父类中是否有h,直到Objectq 如果没找到,则出现编译错误。q 上面步骤,只要找到h变量,则这个过程终止。 ·构造方法调用顺序:构造方法第一句总是:super(…)来调用父类对应的构造方法。所以,流程就是:先向上追溯到Object,然后再依次向下执行类的初始化块和构造方法,直到当前子类为止。
    封装(encapsulation) 封装是面向对象三大特征之一。对于程序合理的封装让外部调用更加方便,更加利于写作。同时,对于实现者来说也更加容易修正和改版代码。
    封装的作用和含义我要看电视,只需要按一下开关和换台就可以了。有必要了解电视机内部的结构吗?有必要碰碰显像管吗?制造厂家为了方便我们使用电视,把复杂的内部细节全部封装起来,只给我们暴露简单的接口,比如:电源开关。具体内部是怎么实现的,我们不需要操心。需要让用户知道的才暴露出来,不需要让用户知道的全部隐藏起来,这就是封装。说的专业一点,封装就是把对象的属性和操作结合为一个独立的整体,并尽可能隐藏对象的内部实现细节。我们程序设计要追求“高内聚,低耦合”。 高内聚就是类的内部数据操作细节自己完成,不允许外部干涉;低耦合是仅暴露少量的方法给外部使用,尽量方便外部调用。
    编程中封装的具体优点:q 提高代码的安全性。q 提高代码的复用性。q “高内聚”:封装细节,便于修改内部代码,提高可维护性。q “低耦合”:简化外部调用,便于调用者使用,便于扩展和协作。
    Java是使用“访问控制符”来控制哪些细节需要封装,哪些细节需要暴露的。 Java中4种“访问控制符”分别为private、default、protected、public,它们说明了面向对象的封装性,所以我们要利用它们尽可能的让访问权限降到最低,从而提高安全性。
    private 表示私有,只有自己类能访问2. default表示没有修饰符修饰,只有同一个包的类能访问3. protected表示可以被同一个包的类以及其他包中的子类访问4. public表示可以被该项目的所有包中的所有类访问
    封装的使用细节类的属性的处理:q 一般使用private访问权限。q 提供相应的get/set方法来访问相关属性,这些方法通常是public修饰的,以提供对属性的赋值与读取操作(注意:boolean变量的get方法是is开头!)。q 一些只用于本类的辅助性方法可以用private修饰,希望其他类调用的方法用public修饰。
    多态概念和实现多态指的是同一个方法调用,由于对象不同可能会有不同的行为。现实生活中,同一个方法,具体实现会完全不同。 比如:同样是调用人的“休息”方法,张三是睡觉,李四是旅游,高淇老师是敲代码,数学教授是做数学题; 同样是调用人“吃饭”的方法,中国人用筷子吃饭,英国人用刀叉吃饭,印度人用手吃饭。多态的要点:1. 多态是方法的多态,不是属性的多态(多态与属性无关)。2. 多态的存在要有3个必要条件:继承,方法重写,父类引用指向子类对象。3. 父类引用指向子类对象后,用该父类引用调用子类重写的方法,此时多态就出现了。
    抽象方法和抽象类·抽象方法 使用abstract修饰的方法,没有方法体,只有声明。定义的是一种“规范”,就是告诉子类必须要给抽象方法提供具体的实现。 ·抽象类 包含抽象方法的类就是抽象类。通过abstract方法定义规范,然后要求子类必须定义具体实现。通过抽象类,我们就可以做到严格限制子类的设计,使子类之间更加通用。
    抽象类的使用要点:1. 有抽象方法的类只能定义成抽象类2. 抽象类不能实例化,即不能用new来实例化抽象类。3. 抽象类可以包含属性、方法、构造方法。但是构造方法不能用来new实例,只能用来被子类调用。4. 抽象类只能用来被继承。5. 抽象方法必须被子类实现。
    接口interface接口就是规范,定义的是一组规则,
    定义接口的详细说明:q 访问修饰符:只能是public或默认。q 接口名:和类名采用相同命名机制。q extends:接口可以多继承。q 常量:接口中的属性只能是常量,总是:public static final 修饰。不写也是。q 方法:接口中的方法只能是:public abstract。 省略的话,也是public abstract。

    接口中定义静态方法和默认方法(JDK8以后)JAVA8之前,接口里的方法要求全部是抽象方法。JAVA8(含8)之后,以后允许在接口里定义默认方法和类方法。 1. 默认方法Java 8及以上旧版本,允许给接口添加一个非抽象的方法实现,只需要使用 default 关键字即可,这个特征又叫做默认方法(也称为扩展方法)。 默认方法和抽象方法的区别是抽象方法必须要被实现,默认方法不是。作为替代方式,接口可以提供默认方法的实现,所有这个接口的实现类都会通过继承得到这个方法。
    静态方法JAVA8以后,我们也可以在接口中直接定义静态方法的实现。这个静态方法直接从属于接口(接口也是类,一种特殊的类),可以通过接口名调用。如果子类中定义了相同名字的静态方法,那就是完全不同的方法了,直接从属于子类。可以通过子类名直接调用。
    接口的多继承接口完全支持多继承。和类的继承类似,子接口扩展某个父接口,将会获得父接口中所定义的一切。
    String是我们开发中最常用的类,我们不仅要掌握String类常见的方法,对于String的底层实现也需要掌握好,不然在工作开发中很容易犯错。
    String基础q String类又称作不可变字符序列。q String位于java.lang包中,Java程序默认导入java.lang包下的所有类。q Java字符串就是Unicode字符序列,例如字符串“Java”就是4个Unicode字符’J’、’a’、’v’、’a’组成的。q Java没有内置的字符串类型,而是在标准Java类库中提供了一个预定义的类String,每个用双引号括起来的字符串都是String类的一个实例。
    字符串相等的判断q equals方法用来检测两个字符串内容是否相等。如果字符串s和t内容相等,则s.equals(t)返回true,否则返回false。q 要测试两个字符串除了大小写区别外是否是相等的,需要使用equalsIgnoreCase方法。q 判断字符串是否相等不要使用"=="。在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 文章目录概述分层思维工程思维对象思维迭代思维 概述 Unix 操作系统诞生于 20 世纪 60 年代,经过几十年的发展,技术日臻成熟。在这个过程中,Unix 独特的设计哲学和美学也深深地吸引了一大批技术开发人员,他们在...


    在这里插入图片描述


    组合思维

    Unix 操作系统诞生于 20 世纪 60 年代,经过几十年的发展,技术日臻成熟。在这个过程中,Unix 独特的设计哲学和美学也深深地吸引了一大批技术开发人员,他们在维护和使用 Unix 的同时,Unix 也影响了他们的思考方式和看待世界的角度。


    Unix 哲学是一套基于 Unix 操作系统顶级开发者们的经验所提出的软件开发的准则和理念

    也就是说,Unix 哲学并不是正统的计算机科学理论,它的形成更多是以经验为基础。你一定听说过模块化、解耦、高内聚低耦合这些设计原则,还有类似开源软件和开源社区文化,这些最早都是起源于 Unix 哲学。可以说 Unix 哲学是过去几十年里对软件行业影响意义最深远的编程文化。

    Unix 设计哲学,主张组合设计,而不是单体设计;主张使用集体智慧,而不是某个人的特殊智慧

    对编程的启示:

    • 启示一:保持简单清晰性,能提升代码质量

    代码之间的相互影响越多,软件越复杂。比如,A 依赖 B,B 依赖 C……一直这样循环下去,程序就会变得非常复杂,也就是我们编程中常说的,如果一个类文件写了上万行代码,那么代码逻辑将会非常难理解。

    软件复杂度一般有以下三个来源。

    • 代码库规模。

      这个就与开发工具、编程语言等有关了,不过需要注意,代码行数与复杂度并不呈正相关。比如,Java 语言编写的库通常会比 C++ 的库的代码行数更多(语言特性决定),但不能说 Java 类库就一定比 C++ 的类库更复杂。

    • 技术复杂度。

      这个指的是不同的编程语言、编译器、服务器架构、操作系统等能够被开发人员理解的难易程度。比如,Netty 库,对于很多 Java 程序员来说,理解起来就有一定的难度,这就是有一定的技术复杂度。

    • 实现复杂度。

      不同的编程人员,对于需求的理解不同,在编程时就会有截然不同的编写风格,比如,前端程序员和后端程序员网页分页的代码实现风格就会明显不同。


    该如何降低软件复杂度呢?

    首先,在代码库规模方面,可以通过减少硬编码来控制代码量

    比如,使用设计模式中的策略模式来替换大量的 if-else 语句,使用通用工具类来减少重复的方法调用。除此之外,还可以利用语言特性来减少代码量,比如,在 Java 8 中使用 lambda 表达式来精简语句。

    其次,对于技术复杂度来说,要想在整体上保持简单性,需要在设计时就做好技术选型

    换句话说,好的技术选型能够有效控制组件引入技术复杂度的风险。比如,在做系统设计时,引入像 Kafka 这样的消息中间件之前,你需要从系统吞吐量、响应时间要求、业务特性、维护成本等综合维度评估技术复杂度,如果你的系统并不需要复杂的消息中间件,那么就不要引入它,因为一旦引入后,就会面临指派人员学习与维护、出现故障后还要能及时修复等问题。

    最后,就降低实现复杂度而言,可以使用统一的代码规范

    比如,使用 Google 开源项目的编码规范,里面包含了命名规范、注释格式、代码格式等要求。这样做的好处在于,能快速统一不同开发人员的编程风格,避免在维护代码时耗费时间去适应不同的代码风格。

    所以,Unix 哲学中所说的保持简单性,并不单单是做到更少的代码量,更是在面对不同复杂度来源时也能始终保持简单清晰的指导原则


    • 启示二:借鉴组合理念,有效应对多变的需求

    对于任何一个开发团队来说,最怕遇见的问题莫过于:不停的需求变更导致不停的代码变更。

    即便你花费了大量的时间,在项目前期做了详细的需求分析和系统的分析设计,依然不能完全阻挡需求的变化,而一旦需求发生变更,那么就意味着开发团队需要加班加点地修改代码。

    事实上,Unix 在设计之初就已经遇见过这些问题,那它是怎么解决的呢?下面我们就来看一下 Unix 那些能够“任意组合”的例子。

    • 所有的命令都可以使用管道来交互

    这样,所有命令间的交互都只和 STD_IN、STD_OUT 设备相关。于是,就可以使用管道来任意地拼装不同的命令,以完成各式各样的功能。

    • 可以任意地替换程序

    比如,我喜欢 zsh,你喜欢 bash,我们可以各自替换;你喜欢 awk,我不喜欢 awk,也可以替换为 gawk。快速切换到熟悉的程序,每个程序就像一个零件一样,任意插拔。

    • 自定义环境变量

    比如,Java 编译环境有很多版本,你可能用到的有版本 8、11 和 14,通过自定义 JAVA_HOME 环境变量,你就可以快速启用不同的编译环境。

    这充分说明了 Unix 哲学的组合思维把软件设计成独立组件并能随意地组合,才能真正应对更多变化的需求。

    然而,在实际工作中,你很多时候可能都只是在做“定制功能驱动”式的程序设计。比如,用户需要一个“上传文件的红色按钮”,你就实现了一个叫“红色上传按钮功能”的组件,过几天变为需要一个“上传文件的绿色按钮”时,你再修改代码满足要求……这不是组合设计,而是直接映射设计,看似用户是需要“上传”这个功能,但实际上用户隐藏了对“不同颜色”的需求。

    很多时候看上去我们是一直在设计不同的程序,实际上对于真正多变的需求,我们并没有做到组合设计,只是通过不断地修改代码来掩饰烂设计罢了。

    要想做到组合设计,Unix 哲学其实给我们提供了两个解决思路。

    第一个是解耦

    这是 Unix 哲学最核心的原则。代码与代码之间的依赖关系越多,程序就越复杂,只有将大程序拆分成小程序,才能让人容易理解它们彼此之间的关系。也就是我们常说的在设计时应尽量分离接口与实现,程序间应该耦合在某个规范与标准上,而不是耦合在具体代码实现逻辑上

    第二个是模块化

    你可能已经非常熟悉这个词语了,不过模块化还有更深层的含义——可替换的一致性。什么叫可替换的一致性?比如,你想使用 Java RPC 协议,可以选择 Dubbo、gRPC 等框架,RPC 协议的本质是一样的,就是远程过程调用,但是实现的组件框架却可以不同,对于使用者来说,只要是支持 Java RPC 协议的框架就行,可随意替换,这是可替换。而不同的框架需要实现同一个功能(远程过程调用)来保持功能的一致性(Dubbo 和 gRPC 的功能是一致的),这是一致性。

    实际上,这两个解决思路就是现在我们常说的高内聚、低耦合原则:模块内部尽量聚合以保持功能的一致性,模块外部尽量通过标准去耦合。

    换句话说,就是提供机制而不是策略,就像上传文件那个例子里,分析时应该找出用户隐含的颜色变化的需求,并抽象出一个可以自定义颜色的功能模块,解耦上传文件模块,最后将颜色变化模块组合到上传文件模块来对外提供使用。这样当用户提出修改颜色时(修改策略),只需要修改自定义颜色模块就行了,而不是连同上传文件的机制也一起修改。


    • 启示三:重拾数据思维,重构优化程序设计

    再高大上的架构设计,如果系统对数据的组织是混乱的,那么可以轻松预见随着系统的演进,系统必然会变得越来越臃肿和不可控。

    Unix 哲学在出现之初便提出了“数据驱动编程”这样一个重要的编程理念。也就是说,在 Unix 的理念中,编程中重要的是数据结构,而不是算法。

    当数据结构发生变化时,通常需要对应用程序代码进行修改,比如,添加新数据库字段、修改程序读写字段等。但在大多数应用程序中,代码变更并不是立即完成的。原因有如下:

    • 对于服务端应用程序而言,可能需要执行增量升级,将新版本部署到灰度环境,检查新版本是否正常运行,然后再完成所有的节点部署;

    • 对于客户端应用程序来说,升不升级就要看用户的心情了,有些用户可能相当长一段时间里都不会去升级软件。

    这就意味着新旧版本的代码以及新旧数据格式可能会在系统中同时共存。这时,处理好数据的兼容性就变得非常重要了。如果不具备数据思维,很可能会假设数据格式的变更不会影响代码变更。

    Unix 哲学提出的“数据驱动编程”会把代码和代码作用的数据结构分开,这样在改变程序的逻辑时,就只要编辑数据结构,而不需要修改代码了


    分层思维

    软件程序通常有两个层面的需求:

    • 功能性需求,简单来说,就是一个程序能为用户做些什么,比如,文件上传、查询数据等;

    • 非功能性需求,这个是指除功能性需求以外的其他必要需求,比如,性能、安全性、容错与恢复、本地化、国际化等。

    事实上,非功能性需求所构建起来的正是我们所熟知的软件架构。什么是软件架构?简单来说,就是软件的基本结构,包括三要素:代码、代码之间的关系和两者各自的属性。

    如果把软件比作一座高楼,那么软件架构就是那个钢筋混凝土的框架,代码就是那个框架里的砖石,正是因为有了那个框架,才能让每一个代码都能很好地运行起来。

    其中,最为经典的软件架构就是分层架构, 分层架构越是流行,我们的设计越容易僵化。这背后到底有哪些值得我们深思的地方呢?

    从架构角度来聊聊为什么代码要做分层、主要用于解决什么问题,以及存在优势和劣势有哪些。

    工程思维

    对象思维

    迭代思维

    展开全文
  • IO)容器Map面向对象技术重载和覆盖的区别面向对象的特征字符串和数组字符串创建与存储的机制”==“、equals()和hashCode有什么区别String、StringBuffer、StringBuilder和StringTokenizer的区别在java中的数组...
  • 产品化思维

    千次阅读 2018-07-06 09:44:54
    微信从一开始到现在,一直保持着核心的功能结构:一套包含众多对象和消息的I/O 系统。其它的功能几乎都以插件的形式存在,甚至,像是根本不存在 同理,公众号也不会让微信复杂,如果你不关注公众号,你不会感受到...
  • 中科大高级软件工程期末复习第六章结构分析(过程论)和第七章面向对象(OO)分析(对象论)——xmind思维导图
  • Java中的class类和对象总结(思维导图)

    千次阅读 多人点赞 2020-11-23 21:54:59
    思维导图: 2. 定义声明对象的两种方法: public class T1{ public static void main{ // 第一种 Person jack; jack = new Person(); ----------------------- //第二种 Person jack = new Person(); } ...
  • MECE结构化思维

    千次阅读 2022-02-25 16:40:08
    MECE结构化思维 MECE是什么 MECE的全写是: Mutually Exclusive Collectively Exhaustive MECE的含义是:相互独立,完全穷尽。也就是,对于一个重大的议题,能够做到不重叠,不遗漏的分类。 ——芭芭拉·明托...
  • 目录一、前情提要二、面向对象1.类 Class2.一个成熟的类3.继承4.多态三、总结四、源码地址 一、前情提要 【七日阅书】1 计算思维和Java特性《Java程序...面向对象可以还原实物的特点,使用的抽象工具分别是 属性:描
  •  优点:复杂的问题简单,流程  缺点:扩展性差  主要应用场景有:Linux内核,git,以及http服务 面向对象的程序设计,核心是对象对象就是特征(变量)与技能(函数)的结合体。  优点:解决
  • MyBatis思维导图.xmind

    2019-06-10 16:46:34
    2019年最新最详细的MyBatis框架思维导图。 mybatis 是一个优秀的基于java的持久层框架,它内部封装了jdbc,使开发者只需要关注sql语句本身,而不需要花费精力去处理加载驱动、创建连接、创建statement等繁杂的过程。...
  • C++知识点思维导图

    2020-02-04 14:16:16
    C++是C语言的继承,它既可以进行C语言的过程程序设计,又可以进行以抽象数据类型为特点的基于对象的程序设计,还可以进行以继承和多态为特点的面向对象的程序设计。C++擅长面向对象程序设计的同时,还可以进行基于...
  • 真的理解面向对象思维

    千次阅读 2017-04-11 14:04:39
    我最后总结出来的结果就是我们在思考面向对象的时候,可能真的是基于某种实现来思考,在实际开发中很有效果,特别是JAVA,但是如果真的想理解面向对象思维,我觉得还是得跳出编程。 万物皆对象 这句话是我在读...
  • 自己总结的jvm中对象的实例内存布局与访问定位的笔记,绘制了详细的思维导图,每个思维导图中均有详细的博文解释,方便大家学习和理解,免费分享给大家。适合jvm的爱好者和学习者
  • python数据科学手册-思维导图。IPython 和 Jupyter(第 1 章)  这两个程序包为许多使用 Python 的数据科学家提供了计算环境。 NumPy(第 2 章)  这个程序库提供了 ndarray 对象,可以用 Python 高效地存储和操 ...
  • 它对JDBC进行了非常轻量级的对象封装,它将POJO与数据库表建立映射关系,是一个全自动的orm框架,hibernate可以自动生成SQL语句,自动执行,使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate...
  • C++作为一种面向对象的语言,其面向对象思维,我觉得非常重要,一直都在研究汇编和C语言,没有对象的观念,但是C++里面,对象思维,抽象思维其实是很有意思的,而且很有意义。  ,我们来分析学习对象数组,对象...
  • 传统与灵活的对象实例方式 静态工厂方法示例: public static Boolean valueOf( boolean b) { return b ? Boolean . TRUE : Boolean . FALSE ; } 的优点和缺点: (PRO) 静态工厂有名字,不像构造函数 (PRO) 静态...
  • Python做自动测试必知必会思维导图

    万次阅读 多人点赞 2020-04-26 14:50:17
    如果想用Python开展自动测试,或者已经开始使用Python但是又不知道应该掌握哪些Python知识的同学们,希望本文能够对你有所帮助。 我是2014年开始接触Python语言的,当时是在Irdeto上班,那时是给数字视频内容保护...
  • java面向对象思维的理解

    千次阅读 2017-10-17 20:52:55
    1.类与对象是什么。 2.如何定义一个类。 3. 构造方法的作用。 4.对象实例与引用 5.成员变量与局部变量 6.匿名对象。 7.封装。 8.this 9.static
  • 思维导图(一):高效的思维工具

    千次阅读 2019-06-15 12:37:36
    非线性思维则是相互连接的,非平面、立体、无中心、无边缘的网状结构,类似于人的大脑结构和血管组织,如发散性思维、系统思维。这两种思维模式虽然存在着巨大的差别,但却无优劣之分,它们之间各有利弊。线性思维...
  • 软件工程思维导图

    2019-02-24 06:34:42
    软件需求获取、规约、结构方法,面向对象方法-UML、RUP,软件测试,软件生存周期过程与管理。
  • Hibernate思维导图

    2018-09-07 22:27:18
    Hibernate主键生成策略,Hibernate持久化对象,Hibernate中session的管理
  • 思维导图原图,可以看视频领取。 C++重点知识整理 入门小知识 命名空间 概念:命名空间是新定义一个作用域,里面可以放函数,变量,定义类等,主要用来防止命名冲突 实现 namespace关键字+命名空间名字{...
  • 它是一种新的思维方式,一种关于计算和信息结构的新思维。面向对象的建模,把系统看作是相互协作的对象,这些对象是结构和行为的封装,都属于某个类,那些类具有某种层次的结构。系统的所有功能通过对象之间相互...
  • 如果想了解更多理论请查阅《ES6学习笔记(一):轻松搞懂面向对象编程、类和对象》、《ES6学习笔记(二):教你玩转类的继承和类的对象》,今天主要来分享关于如何用js面向对象思维来实现tab栏的一些相关的功能。...
  • 初识Python之面向对象篇(上) 初识Python之面向对象篇(下) 知识点思维导图 详细语法案例 '''模拟狗狗的日常''' class Dog(): '''小狗狗''' def __init__(self,name,age): '''初始属性name和age''' self.name=...
  • Java对象序列详解

    万次阅读 多人点赞 2016-08-10 14:47:32
    一、定义 序列:把Java对象转换为字节序列的过程。    反序列:把字节序列恢复为Java对象的过程。二、用途 对象的序列主要有两种用途:    1) 把对象的字节序列永久地保存到硬盘上,通常存放在一...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 141,635
精华内容 56,654
关键字:

对象化思维