程序博客网 > java葵花宝典2015

编程思想

来源：互联网 发布：java葵花宝典2015 编辑：程序博客网 时间：2024/04/30 01:19

《回调的原理、实现与应用》一文中已经初步讲了回调的原理和应用，并就一个实际需求用函数的方式实现了回调应用。但回调并不仅限于回调函数，可以有很多不同的现实方式。回调与其说是一种技术，不如说是一种编程思想，我们在各种计算机语言中都能看到它的踪影。我们以《回调的原理、实现与应用》一文中提到的需求为例，看看C++、JavaScript、Java等各种语言下回调的实现方式。

有一Person类，有年龄(age),体重(weight),身高(height)三个属性。现要对Person的一组对象进行排序，但并没有确定根据什么规则来排序，有时需要根据年龄进行排序，有时需要根据身高进行排序，有时可能是根据身高和体重的综合情况来排序，还有可能……

 

JavaScript的实现

 

  1. <script type="text/javascript">  
  2.           
  3.         //定义一个Person类  
  4.         function Person(_age, _weight, _height)  
  5.         {  
  6.             this.age = _age;  
  7.             this.weight = _weight;  
  8.             this.height = _height;  
  9.         }  
  10.           
  11.         //定义Person类的一个方法  
  12.         Person.prototype.showInfo = function() {  
  13.           document.write("age: " + this.age + "  weight: " + this.weight + "  heigt:" + this.height);  
  14.         };  
  15.           
  16.         //persons为Array数组  
  17.         function sortPerson(persons, funcCompare)  
  18.         {  
  19.             var flag = false;  
  20.             //判断persons是否为数组，判断funcCompare是否为回调 函数  
  21.             flag = (persons instanceof Array) && (funcCompare instanceof Function);  
  22.             if(flag)  
  23.             {  
  24.                 var n = persons.length;  
  25.                 for(var i = 0; i < n-1; i ++)  
  26.                 {  
  27.                     for(var j = 0; j < n-i-1; j ++)  
  28.                     {  
  29.                         if(funcCompare(persons[j], persons[j+1]) > 0)  
  30.                         {  
  31.                             var temp = persons[j];  
  32.                             persons[j] = persons[j+1];  
  33.                             persons[j+1] = temp;  
  34.                         }  
  35.                     }  
  36.                 }  
  37.                 flag = true;  
  38.             }  
  39.             return flag;  
  40.         }  
  41.   
  42.         //根据年龄比较两个Person对象  
  43.         function compareByAge(person1, person2)  
  44.         {  
  45.             return person1.age - person2.age;  
  46.         }  
  47.   
  48.         //根据身高比较两个Person对象  
  49.         function compareByHeight(person1, person2)  
  50.         {  
  51.             return person1.height - person2.height;  
  52.         }  
  53.           
  54.         //在页面上显示Person数组的信息  
  55.         function showPersonArray(persons)  
  56.         {  
  57.             var size = persons.length;  
  58.             for(i = 0; i < size; i ++)  
  59.             {  
  60.                 persons[i].showInfo();  
  61.                 document.write("<br>");  
  62.             }  
  63.         }  
  64.           
  65.     </script>  


 

 

调用：

 

  1. <script type="text/javascript">  
  2.     var persons = new Array();  
  3.     persons[0] = new Person(2, 54.5, 0.82);  
  4.     persons[1] = new Person(31, 74.5, 1.80);  
  5.     persons[2] = new Person(54, 44.5, 1.59);  
  6.     persons[3] = new Person(23, 62.0, 1.78);  
  7.     persons[4] = new Person(16, 45.7, 1.60);  
  8.     document.writeln("before sort:<br>");  
  9.     showPersonArray(persons);  
  10.     sortPerson(persons, compareByAge);  
  11.     document.writeln("finished sort by age:<br>");  
  12.     showPersonArray(persons);  
  13.     sortPerson(persons, compareByHeight);  
  14.     document.writeln("finished sort by Height:<br>");  
  15.     showPersonArray(persons);  
  16. </script>  


 

 

当然，你也可以在调用sortPerson的时候定义一个匿名的回调函数。一种更优雅的书写方式如下：

 

  1. //根据年龄排序  
  2. sortPerson(persons, function(person1, person2){  
  3.     return person1.age - person2.age;  
  4. });  
  5. //根据身高排序  
  6. sortPerson(persons, function(person1, person2){  
  7.     return person1.height - person2.height;  
  8. });  


 

 

JavaScript中Array的sort方法应用的就是这个原理：

arrayObject.sort(sortby)

参数

描述

sortby

可选。规定排序顺序。必须是函数。

 

想更多地了解JavaScript中回调的实现和技术要点，请看下一章《理解和使用 JavaScript 中的回调函数》

 

 

Java的实现

Java中没有像C++这样的函数指针，所以不能将一个函数通过参数传递给另一个函数。因此Java中没有回调函数，但仍然可以有回调的机制。Java是一种纯面向对象的语言，它的回调可以通过面向对象的特性实现。

依然采用Person的例子，用Java实现回调。如下：

 ICompare接口：

 

  1. public interface ICompare {  
  2.     public int comparable(ICompare obj);  
  3. }  

 

 

Person类：

 

  1. public class Person implements ICompare {  
  2.       
  3.     private int age;  
  4.     private float height;  
  5.     private float weight;  
  6.       
  7.     public Person(int age, float height, float weight) {  
  8.         super();  
  9.         this.age = age;  
  10.         this.height = height;  
  11.         this.weight = weight;  
  12.     }  
  13.   
  14.     public int getAge() {  
  15.         return age;  
  16.     }  
  17.   
  18.     public void setAge(int age) {  
  19.         this.age = age;  
  20.     }  
  21.   
  22.     public float getHeight() {  
  23.         return height;  
  24.     }  
  25.   
  26.     public void setHeight(float height) {  
  27.         this.height = height;  
  28.     }  
  29.   
  30.     public float getWeight() {  
  31.         return weight;  
  32.     }  
  33.   
  34.     public void setWeight(float weight) {  
  35.         this.weight = weight;  
  36.     }  
  37.   
  38.     @Override  
  39.     public int comparable(ICompare obj) {  
  40.         Person p = (Person)obj;  
  41.         return this.age - p.age;  
  42.     }  
  43.   
  44. }  


测试：

 

 

  1. public class CallBackTest {  
  2.   
  3.     public static void Sort(ICompare[] objs) {  
  4.         int n = objs.length;  
  5.         for(int i = 0; i < n-1; i ++) {  
  6.             for(int j = 0; j < n-i-1; j ++) {  
  7.                 if(objs[j].comparable(objs[j + 1]) > 0)  
  8.                 {  
  9.                     ICompare temp = objs[j];  
  10.                     objs[j] = objs[j + 1];  
  11.                     objs[j + 1] = temp;  
  12.                 }  
  13.             }  
  14.         }  
  15.     }  
  16.       
  17.     public static void showArray(Person persons[]){  
  18.         for(int i = 0; i < persons.length; i ++) {  
  19.             System.out.println("age:" + persons[i].getAge() + "  weight:" + persons[i].getWeight() + "  height:" + persons[i].getWeight());  
  20.         }  
  21.     }  
  22.       
  23.     /** 
  24.      * @param args 
  25.      */  
  26.     public static void main(String[] args) {  
  27.         Person[] persons = new Person[]{  
  28.                 new Person(2, 54.5f, 0.82f),  
  29.                 new Person(31, 74.5f, 1.80f),  
  30.                 new Person(54, 44.5f, 1.59f),  
  31.                 new Person(23, 62.0f, 1.78f),  
  32.                 new Person(16, 45.7f, 1.60f)  
  33.         };  
  34.         System.out.println("before sort:");  
  35.         showArray(persons);  
  36.         Sort(persons);  
  37.         System.out.println("after sort:");  
  38.         showArray(persons);  
  39.     }  
  40.   
  41. }  



 

java.util.Arrays中的Sort就用到了这种技术，从Java的API中可以看出：

public static void sort(Object[] a)

根据元素的自然顺序，对指定对象数组按升序进行排序。数组中的所有元素都必须实现 Comparable 接口。此外，数组中的所有元素都必须是可相互比较的（也就是说，对于数组中的任何 e1 和 e2 元素而言，e1.compareTo(e2) 不得抛出 ClassCastException）。

 

 

回调之编程思想

在软件模块调用中，主要有三种机制：同步调用，异步调用和回调。

同步调用是调用方（A）call被调用方（B）的接口，并等待B处理完给出一个回执后A才继续执行，这期间是“阻塞”的。

异步调用是调用方（A）call被调用方（B）的接口后，不等待B执行完，且B在被调用后会直接回执A。

回调是调用方（A）call被调用方（B）时，B也回调（callback）被调用方，双方互调接口，只不过call动作是由A发起的。

同步调用是最简单的，异步调用一般是在回调的基础上实现的。所以了解“回调”的机制是至关重要的。

 

以“八仙过海”彰显回调之精髓

 

我们再来看一个例子，用程序模拟“八仙过海，各显神通”。

 

图片来源：昵图网

 

  1. package callback;  
  2.   
  3. /** 
  4.  * 接口 魔法(神通) 
  5.  * @author luoweifu 
  6.  * 
  7.  */  
  8. interface Magic {  
  9.     public void doMagic();  
  10. }  
  11.   
  12. /** 
  13.  * 神仙类 
  14.  * @author luoweifu 
  15.  * 
  16.  */  
  17. class Immortal {  
  18.     private String name;  
  19.     private Magic magic;  
  20.   
  21.     public Immortal(String name) {  
  22.         super();  
  23.         this.name = name;  
  24.     }  
  25.   
  26.     public Immortal(String name, Magic magic) {  
  27.         super();  
  28.         this.name = name;  
  29.         this.magic = magic;  
  30.     }  
  31.   
  32.     public void SetMagic(Magic magic) {  
  33.         this.magic = magic;  
  34.     }  
  35.       
  36.     public String getName() {  
  37.         return name;  
  38.     }  
  39.   
  40.     public void crossingSea(Magic magic) {  
  41.         this.magic = magic;  
  42.         System.out.print(name);  
  43.         magic.doMagic();  
  44.         System.out.println("过海...");  
  45.     }  
  46. }  
  47.   
  48. public class crossingSea {  
  49.   
  50.     /** 
  51.      * 八仙过海，各显神通 
  52.      * @param args 
  53.      */  
  54.     public static void main(String[] args) {  
  55.         Immortal tieGuaiLi = new Immortal("铁拐李");  
  56.         tieGuaiLi.crossingSea(new Magic() {  
  57.             public void doMagic() {  
  58.                 System.out.print("将葫芦变成条葫芦大船");  
  59.             }  
  60.         });  
  61.           
  62.         Immortal zhangGuoLao = new Immortal("张果老");  
  63.         zhangGuoLao.crossingSea(new Magic() {  
  64.             public void doMagic() {  
  65.                 System.out.print("将毛驴变成一只小黑驴");  
  66.             }  
  67.         });  
  68.           
  69.         Immortal heXianGu = new Immortal("何仙姑");  
  70.         heXianGu.crossingSea(new Magic() {  
  71.             public void doMagic() {  
  72.                 System.out.print("将荷叶往海面上一铺，躬身往上一跃，漂浮而去");  
  73.             }  
  74.         });  
  75.           
  76.         Immortal hanXiangzi = new Immortal("韩湘子");  
  77.         hanXiangzi.crossingSea(new Magic() {  
  78.             public void doMagic() {  
  79.                 System.out.print("将玉箫往水中一掷，化作一根浮木，站在上面");  
  80.             }  
  81.         });  
  82.           
  83.         Immortal liDongBin = new Immortal("吕洞宾");  
  84.         liDongBin.crossingSea(new Magic() {  
  85.             public void doMagic() {  
  86.                 System.out.print("把黄龙宝剑投入海中，宝剑化作一只小船载着他");  
  87.             }  
  88.         });  
  89.           
  90.         Immortal lanCaiHe = new Immortal("蓝采和");  
  91.         lanCaiHe.crossingSea(new Magic() {  
  92.             public void doMagic() {  
  93.                 System.out.print("将百花篮变成五彩船悠哉游哉坐上彩船");  
  94.             }  
  95.         });  
  96.           
  97.         Immortal hanZhongLi = new Immortal("汉钟离");  
  98.         hanZhongLi.crossingSea(new Magic() {  
  99.             public void doMagic() {  
  100.                 System.out.print("有一把芭蕉扇，他来了一个鲤鱼大翻 身，躺在扇子上悠闲自得地随波飘荡");  
  101.             }  
  102.         });  
  103.           
  104.         Immortal caoGuoJiu = new Immortal("曹国舅");  
  105.         caoGuoJiu.crossingSea(new Magic() {  
  106.             public void doMagic() {  
  107.                 System.out.print("把阴阳玉板在海面上一字儿排开，犹如脚踏竹排迎激流穿巨浪");  
  108.             }  
  109.         });  
  110.     }  
  111.   
  112. }  

 

 

结果如下：

铁拐李将葫芦变成条葫芦大船过海...
张果老将毛驴变成一只小黑驴过海...
何仙姑将荷叶往海面上一铺，躬身往上一跃，漂浮而去过海...
韩湘子将玉箫往水中一掷，化作一根浮木，站在上面过海...
吕洞宾把黄龙宝剑投入海中，宝剑化作一只小船载着他过海...
蓝采和将百花篮变成五彩船悠哉游哉坐上彩船过海...
汉钟离有一把芭蕉扇，他来了一个鲤鱼大翻 身，躺在扇子上悠闲自得地随波飘荡过海...

 

在面向对象的语言中，回调则是通过接口或抽象类来实现的，我们把实现这种接口的类成为回调类，回调类的对象成为回调对象。对于像C++这样的兼容了过程特性的对象语言，不仅提供了回调对象、回调方法等特性，也能兼容过程语言的回调函数机制。

上面这个例子中Immortal是一个接口，doMagic就是你要实现的回调方法，在调用crossingSea方法时实现的匿名的Magic类是称为回调类，Immortal中的private Magic magic;称为回调对象。传递了这个接口的对象也就传递了这个回调函数的实现，也就是实现了回调。

是不是很有趣？对，就是这么一个有有趣的例子，却淋漓尽致地表现了Java中回调的精髓，你可以反复地体会。上面这个例子在设计模式中也叫观察者模式，大家在别的地方看它的用法就不要再觉得陌生了哦！

 

恰当地使用回调，有以下的作用：

 

      避免重复代码 

      在你需要更多的通用功能的地方更好地实现抽象(可处理各种类型的对象和变量)。

      增强代码的可维护性

      增强代码的可读性

      有更多定制的功能



什么是迭代器？

迭代器(Iterator)是按照一定的顺序对一个或多个容器中的元素从前往遍历的一种机制，比如for循环就是一种最简单的迭代器，对一个数组的遍历也是一种的迭代遍历的过程。GOF给出的定义为：提供一种方法访问一个容器（container）对象中各个元素，而又不需暴露该对象的内部细节。迭代器有时也称为枚举器(Enumerator)，其结构图如下：

迭代器结构图

 

迭代器其实就是维护一个当前的指针，这个指针可以指向当前的元素，可以返回当前所指向的元素，可以移到下一个元素的位置，通过这个指针可以遍历容器的所有元素。迭代器一般至少会有以下几种方法：

First(); //将指针移至第一个位置或获得第一个元素

GetCurrent(); //获得当前所指向的元素

MoveNext(); //移至下一个元素

 

 

如何使用迭代器

既然迭代器是封装里面的实现细节，对外提供方便访问容器元素的接口，那我们就先从使用的角度认识迭代器，看看在各种语言下迭代器是如何使用的。

 

C++中的迭代器：

 

  1. void TestIterator()  
  2. {  
  3.     vector<int> vec;          // 定义一容器  
  4.     for(int i = 0; i < 5; i++)  
  5.     {  
  6.         vec.push_back(i*2);     //添加元素  
  7.     }  
  8.     //用迭代器访问容器中的每个元素  
  9.     cout << "iterator vector:" << endl;  
  10.     for(vector<int>::iterator itr = vec.begin(); itr != vec.end(); itr ++)  
  11.     {  
  12.         cout << *itr << "   ";  //itr是一个指针，指向当前的元素, 所以要解引用获得元素值  
  13.     }  
  14.     cout << endl;  
  15.   
  16.   
  17.     map<int, string> student; //创建一个map，对应学号-姓名的键值对  
  18.     //添加元素  
  19.     student.insert(pair<int, string>(1, "张三"));  
  20.     student.insert(pair<int, string>(3, "王五"));  
  21.     student.insert(pair<int, string>(2, "李四"));  
  22.     //遍历容器中的元素  
  23.     cout << "iterator map:" << endl;  
  24.     for (map<int, string>::iterator itr = student.begin(); itr != student.end(); itr ++)  
  25.     {  
  26.         cout << itr->first << "-->" << itr->second << endl;  
  27.     }  
  28. }  


结果：

 


iterator vector:

0   2   4   6   8

iterator map:

1-->张三

2-->李四

3-->王五

 

c++中的容器(如vector、map、list、set等)一般会提供四个迭代器：

iterator：正向迭代，从前往后遍历，可修改元素的值

const_iterator：正向常量迭代，但不能修改元素的值，因为指向的是const的引用

reverse_iterator：反向迭代，从后往前遍历，可修改元素的值

const_reverse_iterator：反向常量迭代，但不能修改元素的值，因为指向的是const的引用

每一种迭代器都提供一对首尾位置的标志begin和end，其关系如下：

迭代器类型

开始位置标志

末尾位置标志

说明

iterator

begin()

end()

正向迭代

const_iterator

cbegin()

cend()

正向常量迭代

reverse_iterator

rbegin()

rend()

反向迭代

const_reverse_iterator

crbegin()

crend()

反向常量迭代

 

对应的示意图如下：

 图1：正常的迭代

 

 图2：常量值的迭代

 

 

Java中的迭代器：

 

  1. public static void testIterator() {  
  2.     //创建一个列表  
  3.     List<Integer> list = new ArrayList<Integer>();  
  4.     list.add(4);    //添加元素  
  5.     list.add(3);  
  6.     list.add(7);  
  7.   
  8.     //返回一个迭代器，并遍历列表中的元素  
  9.     Iterator<Integer> iterator = list.iterator();  
  10.     while (iterator.hasNext()) {  
  11.         Integer value = iterator.next();  
  12.         System.out.print(value + "    ");  
  13.     }  
  14.     System.out.println();  
  15.   
  16.     //返回ListIterator迭代器并从后往前遍历列表的元素  
  17.     ListIterator<Integer> listIterator = list.listIterator(list.size());  
  18.   
  19.     System.out.println("ListIterator:");  
  20.     while (listIterator.hasPrevious()) {  
  21.         Integer value = listIterator.previous();  
  22.         System.out.print(value + "    ");  
  23.     }  
  24.     System.out.println();  
  25. }  


结果：

 

Iterator begin to end:

4    3    7    

ListIterator end to begin:

7    3    4    

 

Java中的List接口及其实现类可以通过iterator()返回Iterator，或通过listIterator()和listIterator(int index) 返回ListIterator。

Iterator和ListIterator都是迭代器，ListIterator继承自Iterator。Iterator只能对列表进行遍历，且只能从前往后遍历，ListIterator可以修改列表，且可以选择往前或往后遍历。关于Iterator和ListIterator更详细的说明请参见官方API：Iterator和ListIterator

 

JavaScript中的迭代器

JavaScript中表示容器的是Array类型，标准并没有给出对应的迭代器的说明和实现，但我们可以自己实现一个简单的迭代器的功能：

 

  1. <script type="text/javascript">  
  2.   
  3.     //创建一个迭代器，传入的必须是Array类型的数据  
  4.     function makeIterator(array) {  
  5.         var index = 0;  
  6.   
  7.         return {  
  8.             hasNext: function () {  
  9.                 return index < array.length;  
  10.             },  
  11.               
  12.             next: function () {  
  13.                 return this.hasNext ? array[index++] : null;  
  14.             },  
  15.               
  16.             current: function () {  
  17.                 return array[index];  
  18.             }  
  19.         };  
  20.     }  
  21.           
  22.     //创建一个数组并赋值  
  23.     var mycars=new Array();  
  24.     mycars[0]="Saab";  
  25.     mycars[1]="Volvo";  
  26.     mycars[2]="BMW";  
  27.     //将数组mycars生成一个迭代器，并通过迭代器遍历数据元素  
  28.     var iterator = makeIterator(mycars);  
  29.     while (iterator.hasNext()) {  
  30.         document.write(iterator.next() + '<br>');  
  31.     }  
  32. </script>  


结果：

 

Saab

Volvo

BMW

 

mozilla提供的JavaScript 1.7已经添加了迭代器的功能，但现在只能在Firefox浏览器上才有用。如：

 

  1. <script type="application/javascript;version=1.7">  
  2.     var lang = { name: 'JavaScript', birthYear: 1995, age: 19 };  
  3.     //生成一个迭代器  
  4.     var itr = Iterator(lang);  
  5.     document.write('key-value:' + '<br>');  
  6.     for(var key in itr){  
  7.         document.write(key + '<br>');  
  8.     }  
  9.       
  10.     //这个迭代器遍历每一个key值  
  11.     var itr2 = Iterator(lang, false);  
  12.     document.write('key:' + '<br>');  
  13.     for(var key in itr2){  
  14.         document.write(key + '<br>');  
  15.     }  
  16.       
  17.     //这个迭代器遍历每一个索引和值  
  18.     var arrs = ['JavaScript', 'Python', 'Haskell'];  
  19.     var itr3 = Iterator(arrs, false);  
  20.     document.write('index-value:' + '<br>');  
  21.     for(let [i, value] in itr3){  
  22.         document.write(i + ':' + value + '<br>');  
  23.     }  
  24. </script>  


结果：

 

key-value:

name,JavaScript

birthYear,1995

age,19

key:

name,JavaScript

birthYear,1995

age,19

index-value:

0:JavaScript

1:Python

2:Haskell

 

更多关于JavaScript 1.7的迭代器请参见：Iterators and Generators

 

 

迭代器的高级应用

在上面一小节“JavaScript中的迭代器”中，已经对Array数组实现了自己定义的迭代器。以上讲述的迭代器基本都是集合内部的元素具有相同的数据类型，但实际的开发过程中可能会有更复杂的容器结构，假设有如下的需要：

一个公司有多个部门，每个部门有多个人组成，这些人中有开发人员，有测试人员，和与项目相关的其它人员，其结构如下：

 

现在要遍历这个公司的所有开发人员，遍历这个公司的所有测试人员。

 

针对这个需求，我们可以创建一个定制化的迭代器来遍历一个公司所有人员，也可以传入员工类型来遍历指定类型的员工，其类的结构图如下：

 

 

对应的实现代码如下：

git@code.csdn.net:luoweifu/iteratortest.git

对应的调用代码如下：

 

  1. #include "stdafx.h"  
  2. #include <string>  
  3. #include <iostream>  
  4. #include "Person.h"  
  5. #include "Department.h"  
  6. #include "Company.h"  
  7. #include "Enumerator.h"  
  8.   
  9. int _tmain(int argc, _TCHAR* argv[])  
  10. {  
  11.     Company company("Apabi");  
  12.     Department* pDepartMent1 = new Department("开发1部");  
  13.     Department* pDepartMent2 = new Department("开发2部");  
  14.     Department* pDepartMent3 = new Department("内核研发部");  
  15.     company.AddDepartment(pDepartMent1);  
  16.     company.AddDepartment(pDepartMent2);  
  17.     company.AddDepartment(pDepartMent3);  
  18.     int empId = 1;  
  19.   
  20.     Person* pPerson11 = new Developer(empId++, "Developer11", "C++", "智慧城市");  
  21.     Person* pPerson12 = new Developer(empId++, "Developer12", "Java", "智慧城市");  
  22.     Person* pPerson13 = new Developer(empId++, "Developer13", "Java", "智慧城市");  
  23.     Person* pPerson14 = new Developer(empId++, "Developer14", "JavaScript", "智慧城市");  
  24.     Person* pPerson15 = new Tester(empId++, "Tester15", "LoadRunner");  
  25.     Person* pPerson16 = new Tester(empId++, "Tester16", "黑盒测试");  
  26.     cout << pPerson16->GetPersonType() << endl;  
  27.     pDepartMent1->AddPerson(pPerson11);  
  28.     pDepartMent1->AddPerson(pPerson12);  
  29.     pDepartMent1->AddPerson(pPerson13);  
  30.     pDepartMent1->AddPerson(pPerson14);  
  31.     pDepartMent1->AddPerson(pPerson15);  
  32.     pDepartMent1->AddPerson(pPerson16);  
  33.   
  34.     Person* pPerson21 = new Developer(empId++, "Developer21", "IOS", "Mobile");  
  35.     Person* pPerson22 = new Developer(empId++, "Developer22", "Android", "Mobile");  
  36.     Person* pPerson23 = new Tester(empId++, "Tester23", "LoadRunner");  
  37.     Person* pPerson24 = new Tester(empId++, "Tester24", "TestIn");  
  38.     pDepartMent2->AddPerson(pPerson21);  
  39.     pDepartMent2->AddPerson(pPerson22);  
  40.     pDepartMent2->AddPerson(pPerson23);  
  41.     pDepartMent2->AddPerson(pPerson24);  
  42.   
  43.     Person* pPerson31 = new Developer(empId++, "Developer31", "C++", "CEBX内核");  
  44.     Person* pPerson32 = new Developer(empId++, "Developer32", "C++", "CEBX内核");  
  45.     Person* pPerson33 = new Developer(empId++, "Developer33", "C++", "CEBX内核");  
  46.     Person* pPerson34 = new Developer(empId++, "Developer34", "C++", "CEBX内核");  
  47.     Person* pPerson35 = new Tester(empId++, "Tester35", "LoadRunner");  
  48.     pDepartMent3->AddPerson(pPerson31);  
  49.     pDepartMent3->AddPerson(pPerson32);  
  50.     pDepartMent3->AddPerson(pPerson33);  
  51.     pDepartMent3->AddPerson(pPerson34);  
  52.     pDepartMent3->AddPerson(pPerson35);  
  53.       
  54.     //遍历所有开发者  
  55.     cout << "遍历所有开发者：" << endl;  
  56.     Enumerator* pEnumerator1 = company.GetEnumerator(PERSON_DEVELOPER);  
  57.     while(pEnumerator1->MoveNext())  
  58.     {  
  59.         Person* pPerson = pEnumerator1->Current();  
  60.         if (pPerson)  
  61.         {  
  62.             pPerson->showInfo();  
  63.         }  
  64.     }  
  65.     delete pEnumerator1;  
  66.   
  67.     //遍历所有测试人员  
  68.     cout << "遍历所有测试人员：" << endl;  
  69.     Enumerator* pEnumerator2 = company.GetEnumerator(PERSON_TESTER);  
  70.     while(pEnumerator2->MoveNext())  
  71.     {  
  72.         Person* pPerson = pEnumerator2->Current();  
  73.         if (pPerson)  
  74.         {  
  75.             pPerson->showInfo();  
  76.         }  
  77.     }  
  78.     delete pEnumerator2;  
  79.   
  80.     //遍历公司所有员工  
  81.     cout << "遍历公司所有员工：" << endl;  
  82.     Enumerator* pEnumerator3 = company.GetEnumerator(PERSON_TYPE_NONE);  
  83.     while(pEnumerator3->MoveNext())  
  84.     {  
  85.         Person* pPerson = pEnumerator3->Current();  
  86.         if (pPerson)  
  87.         {  
  88.             pPerson->showInfo();  
  89.         }  
  90.     }  
  91.     delete pEnumerator3;  
  92.   
  93.     return 0;  
  94. }  


这样就使得代码简洁易懂易读。

 

 

 

迭代器的应用场景

1.集合的内部结构复杂，不想暴露对象的内部细节，只提供精简的访问方式；

2.需要提供统一的访问接口，从而对不同的集合使用同一的算法。








我之前写过关于递归算法的博文，但作为编程思想系列的文章不得不再对它进行进一步深入的剖析。因为它是一种简单、常用又重要的一种编程思想。

什么叫递归？

举一个通俗的例子：

有一个8俩重的苹果要你切成重量相等的若干份，每一份的重量不能大于1俩。你肯定会想到这样做：

1.第一刀先把一个苹果切成重量均等的2份A1和A2；

2.再把其中的一份A1切成重量均等的两份A11和A12， 把A2切成均等的两份A21和A22；

3.把A11切成均等的两份……

4.直到每一小份都小于等于1俩为止。

以上的例子就是递归一个模型，把一个大的事物化成若干个小的事物，每一次使用的方法都相同。

 

更为专业的定义：

程序自身调用自身的编程技巧称为递归（ recursion）。递归有直接递归和间接递归

•直接递归：函数在执行过程中调用本身。

•间接递归：函数在执行过程中调用其它函数再经过这些函数调用本身。

递归有四个特性：

1.必须有可最终达到的终止条件，否则程序将陷入无穷循环；

2.子问题在规模上比原问题小，或更接近终止条件；

3.子问题可通过再次递归调用求解或因满足终止条件而直接求解；

4.子问题的解应能组合为整个问题的解。

 

上面的例子中也满足以上的四点性质：

(1).终止条件是每一份的重量不能大于1俩；(2).每一次切的大小都比上一次小；(3).每一次切的方式都相同，所以子问题可递归调用；(4).最终切成的每一小份也就是要求的解。

 

对上面例子的实现：

 

  1. public static void sliceApple(float weight, int times){  
  2.         if (weight <= 1) {  
  3.             //System.out.println("weight:" + weight);  
  4.         } else {  
  5.             float w = weight / 2;  
  6.             System.out.println("第" + times + "次等分的重量为：" + w + "   " + w);  
  7.             times += 1;  
  8.             sliceApple(w, times);  
  9.             sliceApple(w, times);  
  10.         }  
  11.     }  
  12.   
  13.     public static void main(String args[]) {  
  14.         sliceApple(8, 1);  
  15.     }  

 

 

结果：

第1次等分的重量为：4.0   4.0

第2次等分的重量为：2.0   2.0

第3次等分的重量为：1.0   1.0

第3次等分的重量为：1.0   1.0

第2次等分的重量为：2.0   2.0

第3次等分的重量为：1.0   1.0

第3次等分的重量为：1.0   1.0

 

递归能做什么？

将大问题分解成小问题，将复杂的问题简单化；

使程序更易于理解，增强可读性；

你会怎样使用递归？

分析问题，看看问题是否属于递归模型，能否用递归模型解决。一个问题能否用递归模型就看它是否满足递归的四个特性。

递归在调用的时候要保存调用点的信息，因此会有调用开销。在对效率有较高要求的时候，如果能用循环解决问题最好不要用递归，因为循环没有调用开销，效率会更高


0 0
java葵花宝典2015 java葵花宝典2015
原创粉丝点击
热门IT博客
iphone 手机铃声软件iphone 手机铃声软件
老七淘宝店老七淘宝店
nba季后赛各项数据统计
腾讯电脑软件管家
windows版keynote
初学者羽毛球拍知乎
图像语义分割 python
电子眼地图数据
手机工程算量软件
网络借贷不还会坐牢吗
淘宝网店怎么安装旺旺
交换机的端口镜像
关于前端程序员的书
qt淘宝刷平台哪个好
中央司法警官学院 知乎
常见的网络安全技术
python字符串编码转换
威斯康辛麦迪逊 知乎
概率统计分析软件
Java treeset倒序
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 绝世盘龙 张龙 张龙 西北大学 狂龙张龙 张龙周晴 张龙赵虎 龙门枭雄主角张龙 5188全文免费阅读张龙免费 枭雄免费阅读全文张龙 弢 弢怎么读 弢是什么意思 弢怎么读拼音 弢字怎么读 弥 须弥 弥弥 卑弥呼 历久弥新 弥月之喜什么意思 草间弥生 万界系统弥煞 爱弥儿 阿尔忒弥斯 老而弥坚 新山沙弥 弥豆子图片 鬼灭之刃弥豆子h 不死川玄弥 静芳年须弥普普 不死川实弥 弥顿道 弥月之喜 草间弥生简介 弥凝 弥助不对这不是我的名字 弥勒 红河弥勒 弥勒图片 弥勒菩萨 弥勒温泉 弥勒市 云南弥勒

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里