精华内容
下载资源
问答
  • 抽象与逐步求精

    2019-10-03 14:24:17
    它可以忽略一个主题中当前目标无关的那些方面,以便更充分地注意当前目标有关的方面。抽象并不打算了解全部问题,而只是选择其中的一部分,暂时不用部分细节。抽象包括两个方面,一是过程...

    https://baike.baidu.com/item/抽象/9021815

    抽象(Abstraction)是简化复杂的现实问题的途径,它可以为具体问题找到最恰当的类定义,并且可以在最恰当的继承级别解释问题。它可以忽略一个主题中与当前目标无关的那些方面,以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题,而只是选择其中的一部分,暂时不用部分细节。抽象包括两个方面,一是过程抽象,二是数据抽象。它侧重于相关的细节和忽略不相关的细节。抽象作为识别基本行为和消除不相关的和繁琐的细节的过程,允许设计师专注于解决一个问题的考虑有关细节而不考虑不相关的较低级别的细节。

     

    软件工程过程中的每一步都可以看作是对软件解决方法的抽象层次的一次细化。在进行软件设计时,抽象与逐步求精模块化密切相关,帮助我们定义软件结构中模块的实体,由抽象到具体地分析和构造出软件的层次结构,提高软件的可理解性。

     

    逐步求精

      将现实问题经过几次抽象(细化)处理,最后到求解域中只是一些简单的算法描述算法实现问题。即将系统功能按层次进行分解,每一层不断将功能细化,到最后一层都是功能单一、简单易实现的模块。求解过程可以划分为若干个阶段,在不同阶段采用不同的工具来描述问题。在每个阶段有不同的规则和标准,产生出不同阶段的文档资料。

    转载于:https://www.cnblogs.com/feng9exe/p/7658943.html

    展开全文
  • 软件设计基础——抽象与逐步求精

    千次阅读 2015-06-08 18:12:06
    抽象与逐步求精  软件设计的困难随着问题的规模和复杂性不断增大,抽象是管理、控制复杂性的基本策略。“抽象”是一个心理学概念,它要求人们将注意力集中在某一个层次上思考问题,而忽略那些低层次的细节。使用...

    抽象与逐步求精


           软件设计的困难随着问题的规模和复杂性不断增大,抽象是管理、控制复杂性的基本策略。“抽象”是一个心理学概念,它要求人们将注意力集中在某一个层次上思考问题,而忽略那些低层次的细节。使用抽象技术便于人们用“问题域“本来的概念和术语描述问题,而无须过早地转换为那些不熟悉的结构。软件设计过程应当是在不同抽象级别考虑、处理问题的过程。最初,应该在最高抽象级别上,用面向问题域的语言叙述问题,概括问题解的形式,而后不断地具体化,不断地更接近计算机域的语言描述问题;最后,在最低的抽象级别上给出可直接实现的问题解,即程序。


            软件工程过程的每一步都是对较高一级抽象的解作一次比较具体化的描述。在系统定义阶段,软件系统被描述为基于计算机的大系统的一个组成部分,在软件规划和需求分析阶段,软件用问题域约定的习惯用语表达;从概要设计过度到详细设计时,抽象级别再一次降低;编码完成后则达到了抽象的最低级。在上述由高级抽象到低级抽象的转换过程中,伴随着一连串的过程抽象和数据抽象。过程抽象把完成一个特定功能的动作序列抽象为一个过程名和参数表,以后通过指定过程名和实际参数调用此过程;数据抽象把一个数据对象的定义(或描述)抽象为一个数据类型名,用此类型名可定义多个具有相同性质的数据对象。


            ”逐步求精“是与”抽象“密切相关的一个概念,可视为一种早起的自顶向下设计策略,其主要思想是,针对某个功能的宏观描述,使用逐步求精的方法不断的分解,逐步确立过程细节,直到该过程能用程序语言描述的算法实现为止。因为求精的每一步都是用更为详细的描述代替上一层次的抽象描述,所以在整个设计过程中,产生的具有不同详细程度的各种描述,组成了系统层次结构。层次结构的上一层还是下一层的抽象,下一层是上一层的求精。在过程求精的同时自然伴随着数据的求精,无论是过程还是数据,每个求精步骤都蕴含着某些设计决策,因此设计人员必须掌握一些基本的准则和各种可能的候选方法。


            在软件设计过程中,抽象与逐步求精一般都是结合起来进行应用,在建立了较高层次的抽象模型后,对其进行求精得到更加具体的抽象模型,然后再进行求精……由此一直到达最终的软件实现。该过程在面向对象软件开发过程中更加直观,因为面向对象的概念层抽象与最终类组成的系统实现具有自然的映射关系。其开发过程可以从概念建模逐步精化为最终的软件实现。


    展开全文
  • 运用“方法抽象”的思想去编程会提高代码的重用性,也提高了开发的效率,是不得不掌握的程序开发思想方法

           首先啰嗦两句,在其他语言中方法称为过程(无返回值)或函数(有返回值)。Java中main方法是由Java虚拟机调用的,其方法头永远都是public static void main(String[]args)。另外,理解相关概念:方法头、方法体、修饰符、方法名、方法签名、参数列表、形式参数。

           方法的抽象和逐步求精:方法抽象是指将方法的使用和它的实现分离。逐步求精就是分治的思想,将大问题分解成子问题,子问题有分解为更小、更容易处理的问题。讲文字太过理论枯燥,下面以一道编程题目展开阐述。

           示例:假设编写一个程序,显示给定的年月和日历。程序提示用户输入年份和月份,然后显示该月的整个日历,运行效果如右图所示:

           你会立即开始编写代码吗?一个好的程序员应该学会程序设计前期的自顶向下的思维培养,应该先用方法抽象把细节与设计分离,只有在最后才实现这些细节。

           如上例子,可以先拆分为两个子问题:读入用户输入打印该年、月的日历。分解之后首先考虑的问题是还能分解成更小更简单的问题吗,而不是考虑用什么方法来读入和打印整个日历。可以画一个结构图来帮助思考。

           打印给定月份的日历问题可以分解成两个子问题:打印日历的标题(由年月、虚线、每周七天的星期名称)和日历的主体(第一天是周几、该月有几天、如何控制天数循环显示)。

           再继续往下分解,怎样知道某月第一天是周几呢?1)可以用最经典的泽勒一致性公式去求解(该方法在Java基本功练习二中介绍了,可以去参看);2)还有种办法是假如知道某一年,如1800年1月1日是星期三,然后计算1800年1月1日和日历月份之间相差的总天数,在用这个总天数+“3”对7求余运算(本例采用第2中方法)。

           如何知道总天数呢?需要知道该年是否是闰年以及每个月的天数。循环显示就最基本了,用计数器对7求余运算即可。另外:不得不考虑的是显示怎么对齐以保持美观的问题。思路分析的结构图如下图所示:


           到这里这个程序的整体的设计思路才算理清楚了,那么接下来就是如何实现各个子问题了。一般来说,每个子问题都对应实现中的一个方法,即使某些子问题太简单,以至于不需要方法来实现。决定哪些模块用方法实现,哪些模块要结合在另一个方法中,是基于整个程序易于读懂的原则的。例如本例中的年月的输入在main方法中就可以实现了。

           为了设计的流畅,建议采用自顶向下的方法来实现每个方法的框架,而用待完善的方法体来代替具体的方法体,先把框架搭建起来,后续在用自底向上的方法来丰富每个待完善的方法体,这样整个设计的思路和准确度都会提高不少。下面是自顶向下的设计框架源代码:

    package PrintCalendar;
    
    import java.util.Scanner;
    public class PrintCalendar {
    	public static void main(String[] args) {
    		//自顶向下的框架设计
    		Scanner input = new Scanner(System.in);
    		System.out.print("Enter full year (e.g 2014): ");
    		int year = input.nextInt();
    		System.out.print("Enter month as number between 1 and 12: ");
    		int month = input.nextInt();
    		printMonth(year,month);
    		}
    		
    		//打印月份
    		public static void printMonth(int year, int month){
    			System.out.print(month+" "+year);
    		}
    		//打印月份的标题
    		public static void printMonthTile(int year,int month){
    			
    		}
    		//打印月份的主体
    		public static void printMonthBody(int year,int month){
    			
    		}
    		//得到月份对应的英文字符串
    		public static String getMonthName(int month){
    			return "January";
    		}
    		//得到某个月第一天的星期数
    		public static int getStartDay(int year,int month){
    			return 10000;
    		}
    		//得到某个月的天数
    		public static int getNumberOfDaysInMonth(int year,int month){
    			return 31;
    		}
    		//判断某年是否是闰年
    		public static boolean isLeapYear(int year){
    			return true;
    		}
    }

           然后编译检测是否有错误,运行结果如右图所示:

           可以看出并没有编译运行等错误,证明主体框架的编写是对的(这样后期出错就排除了框架出错的可能,缩小了排错范围,提高效率)。现在就运用自底向上的方法进行设计细节的实现了。下面是设计好的源代码:

    package PrintCalendar;
    
    import java.util.Scanner;
    public class PrintCalendar {
    	public static void main(String[] args) {
    		Scanner input = new Scanner(System.in);
    		System.out.print("Enter full year (e.g 2014): ");
    		int year = input.nextInt();
    		System.out.print("Enter month as number between 1 and 12 (e.g 12): ");
    		int month = input.nextInt();
    		//打印用户输入的年月份的日历
    		printMonth(year,month);
    	}
    
    	//打印月份
    	public static void printMonth(int year, int month){
    		printMonthTile(year,month);
    		printMonthBody(year,month);
    	}
    	//打印月份的标题
    	public static void printMonthTile(int year,int month){
    		System.out.println("\t"+getMonthName(month)+"  "+year);
    		System.out.println("------------------------------");
    		System.out.println(" Sun Mon Tue Wed Thu Fri Sat");
    	}
    	//打印月份的主体
    	public static void printMonthBody(int year,int month){
    		int startDay = getStartDay(year,month);
    		int numberOfDaysInMonth = getNumberOfDaysInMonth(year, month);
    		int i = 0;
    		for(i = 0;i < startDay; i++)
    			System.out.print("    ");
    		for(i = 1;i <= numberOfDaysInMonth;i++){
    			System.out.printf("%4d",i);
    			if((i + startDay) % 7 == 0)
    				System.out.println();
    		}
    		System.out.println();
    	}
    	//得到月份对应的英文字符串
    	public static String getMonthName(int month){
    		String monthName = "";
    		switch(month){
    		  case 1:monthName = "January";break;
    		  case 2:monthName = "February";break;
    		  case 3:monthName = "March";break;
    		  case 4:monthName = "April";break;
    		  case 5:monthName = "May";break;
    		  case 6:monthName = "June";break;
    		  case 7:monthName = "July";break;
    		  case 8:monthName = "August";break;
    		  case 9:monthName = "September";break;
    		  case 10:monthName = "October";break;
    		  case 11:monthName = "November";break;
    		  case 12:monthName = "December";break;
    		}
    		return monthName;
    	}
    	//得到某个月第一天的星期数
    	public static int getStartDay(int year,int month){
    		final int START_DAY_FOR_JAN_1_1800 = 3;
    		//得到从1800,1,1到year,month,1之间的天数
    		int totalNumberOfDays = getTotalNumberOfDays(year,month);
    		//返回year,month,1的开始天
    		return (totalNumberOfDays + START_DAY_FOR_JAN_1_1800) % 7;
    	}
    	//得到年份之间的总天数
    	public static int getTotalNumberOfDays(int year,int month){
    		int total = 0;
    		//得到从1800到1/1/year的总天数
    		for(int i = 1800; i < year;i++){
    			if(isLeapYear(i))
    				total += 366;
    			else
    				total +=365;
    		}
    		//将一月到日历月的天数加到总天数中去
    		for(int i = 1;i < month;i++)
    			total +=getNumberOfDaysInMonth(year,i);
    		return total;
    	}
    	//得到某个月的天数
    	public static int getNumberOfDaysInMonth(int year,int month){
    		if(month == 1 || month == 3 || month == 5 || month == 7 || 
    				month == 8 || month == 10 || month == 12)
    			return 31;
    		if(month == 4 || month == 6 || month == 9 || month == 11)
    			return 30;
    		if(month == 2) 
    			return isLeapYear(year) ? 29 : 28;
    		return 0;//如果输入了无效月份返回0
    	}
    	//判断某年是否是闰年
    	public static boolean isLeapYear(int year){
    		return year % 400 == 0||(year % 4 == 0 && year % 100 != 0);
    	}
    }

           运行效果如右图所示:

           这样就完成了整个程序的开发流程,虽然开发步骤较多,从表面上似乎浪费了开发时间,但实际上更节省,并且调试更加容易,程序更加整齐、层次明显。程序的主体(通常就是指main方法)可以编写成由简单的方法构成的集合,更容易编写、调试、维护和修改了,并且最重要的是方法的可重用性非常高。为后续的团队开发和移植带来不可估量的好处。所以代码的规范化、方法的抽象、逐步求精有多重要,大家慢慢体会!!

    展开全文
  • 逐步求精

    2017-03-06 16:12:57
    逐步求精定义为为了能集中精力解决主要问题而尽量推迟对问题细节的考虑。 逐步求精最初是由NiklausWirth提出的一种自顶向下的设计策略。按照这种设计策略,程序的体系结构是通过逐步精...抽象与求精是一对互补的概念。

    逐步求精定义为为了能集中精力解决主要问题而尽量推迟对问题细节的考虑。

    逐步求精最初是由NiklausWirth提出的一种自顶向下的设计策略。按照这种设计策略,程序的体系结构是通过逐步精化处理过程的层次而设计出来的。通过逐步分解对功能的宏观陈述而开发出层次结构,直至最终得出用程序设计语言表达的程序。

    求精实际上是细化过程。
    抽象与求精是一对互补的概念。
    展开全文
  • “自顶向下,逐步求精”的方法

    千次阅读 2017-11-27 01:33:52
    而其中,结构化程序设计支持“自顶向下, 逐步求精”的程序设计方法。 “自顶向下”的具体内涵是将复杂、大的问题划分为小问题,找出问题的关键、重点所在,然后用精确的思维定性、定量地去描述问题。而“逐步求精”...
  • 逐步求精:将现实问题经过几次抽象(细化)处理,最后到求解域中只是一些简单的算法描述和算法实现问题。即将系统功能按层次进行分解,每一层不断将功能细化,到最后一层都是功能单一、简单易实现的模块。** 在这里...
  • 自顶向下是将复杂、大的问题划分为小问题,找出问题的关键、重点所在,然后用精确的思维定性、定量地去描述问题。... 自顶向下,逐步求精方法在打代码中经常用到。  例如要打出如图所示的图案  
  • 简单介绍“自顶向下, 逐步求精”的程序设计方法我们首先来对”自顶向下,逐步求精“有个简单的了解自顶向下自顶向下是将复杂、大的问题划分为小问题,找出问题的关键、重点所在,然后用精确的思维定性、定量地去描述...
  • 逐步求精” 是将现实世界的问题经抽象转化为逻辑空间或求解空间的问题。复杂问题经抽象化处理变为相对比较简单的问题。经若干步抽象(精化)处理,最后到求解域中只是比较简单的编程问题。 总的来说,就是采用模块...
  • 结构化程序设计支持“自顶向下, 逐步求精”的程序设计方法。什么叫作“自顶向下,逐步求精”呢?“自顶向下” 将复杂的大问题分解为相对简单的小问题,找出每个问题的关键、重点所在,然后用精确的思维定性、定量地...
  • 结构化程序设计支持“自顶向下, 逐步求精”的程序设计方法。 首先,“自顶向下” 是将复杂、大的问题划分为小问题,找出问题的关键、重点所在,然后用精确的思维定性、定量地去描述问题。 其次,“逐步求精” 是...
  • “自顶向下 逐步求精”的设计方法

    千次阅读 2017-11-25 20:41:59
    “自顶向下 逐步求精”的设计方法 什么是 “自顶向下 逐步求精”的设计方法 自顶向下的设计方法是一种程序开发技术,其中问题被分解为更容易处理的子问题,这些子问题的解决方案组合起来构成整体问题的解决...
  • 自上而下,逐步求精

    2017-11-28 23:03:26
    而”逐步求精“是则将现实世界的问题经抽象转化为逻辑空间或求解空间的问题,复杂问题经抽象化处理变为相对比较简单的问题,经若干步抽象(精化)处理之后,最后到求解域中只是比较简单的编程问题。 首先,先来看...
  • 自顶向下,逐步求精的程序设计方法。“自顶向下” 是将复杂、大的问题划分为小问题,找出问题的关键、重点所在,然后用精确的思维定性、定量地去描述问题。“逐步求精” 是将现实世界的问题经抽象转化为逻辑空间或...
  • 今天我们先介绍“自顶向下,逐步求精”的程序设计方法。 所谓“自顶向下”,即是把一个抽象的,困难的大问题分解为若干个小问题,如果认为小问题仍然不够简单可行,就再进一步分解,直到每一个小问题都简单易解。 ...
  • 自顶向下设计自顶向下设计, 一种逐步求精的设计程序的过程和方法。对要完成的任务进行分解,先对最高层次中的问题进行定义、设计、编程和测试,而将其中未解决的问题作为一个子任务放到下一层次中去解决。这样逐层...
  • 逐步求精”   是将现实世界的问题经抽象转化为逻辑空间或求解空间的问题。复杂问题经抽象化处理变为相对比较简单的问题。经若干步抽象(精化)处理,最后到求解域中只是比较简单的编程问题。   “自顶向下...
  • 最近看知乎某答主提到“自顶向下,逐步求精”的思想,很受启发,在这里写下自己的理解和感悟吧。 什么是“自顶向下,逐步求精”? 自顶向下 把问题分解成一套子问题,然后把子问题分解成更小的问题。这一过程将一直...
  • 自顶向下,逐步求精

    2017-11-29 15:04:32
    而其中,结构化程序设计支持“自顶向下, 逐步求精”的程序设计方法。 “自顶向下”的具体内涵是将复杂、大的问题划分为小问题,找出问题的关键、重点所在,然后用精确的思维定性、定量地去描述问题。而“逐步求精”...
  • 结构化程序设计支持“自顶向下, 逐步求精”的程序设计方法。 “自顶向下” 是将复杂、大的问题划分为小问题,找出问题的关键、重点所在,然后用精确的思维定性、定量地去描述问题。 “逐步求精” 是将...
  • 自顶向下 逐步求精

    2017-11-26 22:48:10
    “自顶向下, 逐步求精

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,849
精华内容 1,139
关键字:

方法抽象与逐步求精