博客园_幸运星空

C#面向对象模式设计第十七讲：Mediator 中介者模式（行为型模式）

2012-01-13T09:42:00Z

（根据MSDN WebCast相关课程整理）

中介者模式的依赖关系：

多个对象彼此之间存在错综复杂的依赖关系，当一个对象发生变化时，可能会引发多个对象随之发生变化。当采用一个中间对象后，该对象不保存与其它对象的引用，各个对象只和这个中间对象发生依赖后，问题就变化简单明晰啦。

设计模式就是用方法来解耦，解耦的目的为了应对变化。

GoF：用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式的相互引用，它们都由中介者来引用，从而使耦合松散，而且可以独立的改变他们之间的交互。

中介者起到了管理复杂关系的作用。

示例，我们通过“Cut”菜单来剪切文本框中的文本，同时允许撤消操作：

各个原来相依赖的对象都继承自Element类，这样，它们就都可以引用mediator对象，而Mediator类中又拥有各大对象的引用List，这就实现了对各对象的引用，从而，实现了mediator与各个对象之间的相互引用，而去掉了各对象之间的引用。

<完>

本文链接

C#面向对象模式设计第十六讲：Interpreter 解释器模式（行为型模式）

2012-01-11T10:04:00Z

（根据MSDN WebCast相关课程整理）

把变化的东西抽象成一种类似于“语言”的东西，让我们的对象来解析它，从而适应变化的需求。

示例：在一个将汉字转化为数字的项目中，随着需要解析的汉字数据越来越大，需要解析方法能够随之处理更大级别的数据（万，亿…），通过扩展Express类，产生能够解析新增的级别的处理方法。

<完>

本文链接

C#面向对象模式设计第十五讲：Command 命令模式（行为型模式）

2012-01-10T10:13:00Z

（根据MSDN WebCast相关课程整理）

实体对象与行为操作之间往往也存在耦合关系。

行为请求者通过“命令”行为实现者去执行一定的行为。

GoF：将请求封装成一个对象，从而使我们可用不同的请求对客户程序进行参数化操作，以及对请求排队或记录讲求日志，以及支持可撤销的操作。

把ClientProgram对Receive.Action()的紧耦合的调用，变为对具体命令对象(ConcreteCommand对象)的调用，从而实现对多变的行为的有效管理。

通过ArrayList或堆栈来管理各个抽象后的行为。

<完>

本文链接

C#面向对象模式设计第十四讲：Template Method 模板模式（行为型模式）

2012-01-10T09:02:00Z

（根据MSDN WebCast相关课程整理）

变化是软件设计中永恒的主题，如何管理变化带来的复杂性？设计模式的艺术性与复杂度就在于如何分析并发现系统中的变化点和稳定点，并使用特定的设计方法来应对这种变化。

事件架构稳定，而子步骤经常改变。

GoF：定义一个操作中的算法的框架，而将一些步骤延迟到子类中，Template Method使用是子类可以不改变一个算法的结构即可以重定义该算法的某些特定步骤。

框架的步骤在TemplateMethod()方法中实现。这些步骤不会变动。而特定的方法步骤则在子类中实现。

示例：如下面的汽车测试平台软件的例子，由框架和实现应用两部分组成。

<完>

本文链接

Android中数据共享机制的实现——ContentProvider的应用从入门到精通

2011-12-31T07:34:00Z

Android中的Content Provider可以实现在权限许可的情况下，在多个应用程序之间共享数据。Android还提供了一些主要数据类型如音频、视频、图片和私人通讯录等现成的Content provider类。当然，如果我们想让我们应用程序的数据公有化，使其它应用也可以访问，那么，我们可以实现一个自己的ContentProvider类。

一种类型的ContentProvider只允许有一个实例，但它可以和多个不同的应用程序或进程的ContentResolver进行通信。进程间的交互就是由ContentResolver和ContentProvider一起完成的。我们可以通过getContentResolver()方法来获得 ContentResolver对象。

数据模型：

ContentProvider以数据表的形式对外暴露，其中每一行数据都有一个唯一的_ID值。每次查询数据时都会返回一个Cursor 对象。不过使用Cursor对象获取数据前一定要先知道数据的类型。

Android中通过URI来定位各种资源，每一个可以调用的资源都有一个唯一的URI，如图片，视频等。同样，ContentProvider中的每一个表也各有一个唯一的URI。ContentProvider提供的URI都是以content://开头的。在所有ContentProvider交互中都要用到URI，而且，每个ContentResolver方法的第一个参数就是URI，它告诉ContentResolver方法要访问的ContentProvider对象，以及操作的目标表。因此，为了方便，给自定义ContentProvider中的URI指定一个专门的CONTENT_URI常量是很有必要的。

通过Content Provider查询数据前要准备的：

1，要查询数据的Provider的URI；

2，要查询的数据的列名以及它们的数据类型；其中_ID和_COUNT列唯一某行数据以及总数据行数。

3，如果是某一行数据，还需要知道它的ID值；如果_ID＝23 则为“content://. . . ./23”

查询数据：

可以用ContentResolver.query()方法或Activity.managedQuery()方法来获取结果Cursor。后者得到的Cursor的生命周期由Activity来管理，而不需要我们再手动关闭游标，我们还可以方便的精确控制它的加载与释放。Activity.startManagingCursor()方法可以将未受管理的游标加入到管理列表中（注：2.3版以后推荐使用getLoaderManager()得到LoaderManger对象来管理游标）stopManagingCursor(Cursor)可以停止自动管理功能。

1，获取URI：

ContentUris.withAppendedId()

Uri.withAppendedPath()

以上两个方法都可以实现将参数（ID）添加到查询URI当中去。

而ContentUris.parseId(uri)方法可以获取URI中的ID部分。

示例：

import android.provider.Contacts.People;

import android.content.ContentUris;

import android.net.Uri;

import android.database.Cursor;

Uri myPerson = ContentUris.withAppendedId(People.CONTENT_URI, 23);

Uri myPerson = Uri.withAppendedPath(People.CONTENT_URI, "23");

Cursor cur = managedQuery(myPerson, null, null, null, null);

2，读取数据：

private void getColumnData(Cursor cur){

if (cur.moveToFirst()) {

String name;

String phoneNumber;

int nameColumn = cur.getColumnIndex(People.NAME);

int phoneColumn = cur.getColumnIndex(People.NUMBER);

String imagePath;

do {

// Get the field values

name = cur.getString(nameColumn);

phoneNumber = cur.getString(phoneColumn);

// Do something with the values.

...

} while (cur.moveToNext());

}

如果是较小的二进制数据，可以直接像普通数据一样保存到表中去，但如果二进制数据量较大，且表的URI是content:URI形式的，则我们需要采用ContentResolver.openInputStream()方法来获得数据流，以便读取数据。

所有数据的更改都需要调用ContentResolver的方法来完成。

首先，将要更改的数据保存到ContentValues对象中，然后调用ContentResolver的相应方法面完成更新操作，示例：

增加新记录：

ContentValues values = new ContentValues();

values.put(People.NAME, "Abraham Lincoln");

values.put(People.STARRED, 1);

Uri uri = getContentResolver().insert(People.CONTENT_URI, values);

在原有记录上增加新值：

Uri phoneUri = null;

phoneUri = Uri.withAppendedPath(uri, People.Phones.CONTENT_DIRECTORY);

values.clear();

values.put(People.Phones.TYPE, People.Phones.TYPE_MOBILE);

values.put(People.Phones.NUMBER, "1233214567");

getContentResolver().insert(phoneUri, values);

其中的CONTENT_DIRECTORY是一个常量，表明这是追加的数据。

如果数据是content:URI形式的二进制大对象，调用ContentResolver.openOutputStream()来保存。

大二进制数据（多媒体数据）处理示例：

import android.provider.MediaStore.Images.Media;

import android.content.ContentValues;

import java.io.OutputStream;

// Save the name and description of an image in a ContentValues map.

ContentValues values = new ContentValues(3);

values.put(Media.DISPLAY_NAME, "road_trip_1");

values.put(Media.DESCRIPTION, "Day 1, trip to Los Angeles");

values.put(Media.MIME_TYPE, "image/jpeg");

// Add a new record without the bitmap, but with the values just set.

// insert() returns the URI of the new record.

Uri uri = getContentResolver().insert(Media.EXTERNAL_CONTENT_URI, values);

// Now get a handle to the file for that record, and save the data into it.

// Here, sourceBitmap is a Bitmap object representing the file to save to the database.

try {

OutputStream outStream = getContentResolver().openOutputStream(uri);

sourceBitmap.compress(Bitmap.CompressFormat.JPEG, 50, outStream);

outStream.close();

} catch (Exception e) {

Log.e(TAG, "exception while writing image", e);

}

实现我们自己的Content Provider：

1，需要创建一个类并且继承ContentProvider类，并实现这个抽象类中的六个方法。

public int delete(Uri uri, String selection, String[] selectionArgs){}

public Uri insert(Uri uri, ContentValues values) {}

public Cursor query(Uri uri, String[] projection, String selection,

String[] selectionArgs, String sortOrder) {} //SQLiteCursor,MatrixCursor

public int update(Uri uri, ContentValues values, String selection,

String[] selectionArgs) {}

public boolean onCreate() {}

public String getType(Uri uri) {}

2，定义URI常量：

public static final Uri CONTENT_URI；

CONTENT_URI＝Uri.parse("content://com.example.codelab.transportationprovider");

3，定义列名，不要忘记_ID列。

public static String ColumnName

4，如果我们的数据在是新的类型，必须在getType ()中返回这个定义好的MIME 类型，自定义类型的名称格式为：

vnd.android.cursor.item/vnd.yourcompanyname.contenttype

vnd.android.cursor.dir/vnd.yourcompanyname.contenttype

5，当保存大二进制数据时，列名下实际存储的是content:URI，另声明一个“_data”列，保存文件的真实路径，以供ContentResolver.openInputStream()时访问。

6，当数据发生改变时，最好还要调用ContentResolver.notifyChange()方法，来通知调用程序。

7，在AndroidManifest.xml中声明ContentProvider。

示例：

<provider android:name=".AutoInfoProvider"

android:authorities="com.example.autos.autoinfoprovider"

. . . />

</provider>

<provider>标签的属性中还可以设置ContentProvider的更多参数。

一个完整的自定义ContentProvider及共享调用与事件侦听的例子：

数据结构User.java：

Java代码

1. package com.yaku.pojo;

3. public class User {

4. private int id;

5. private String name;

6. private int age;

8. public User(int id, String name, int age) {

9. super();

10. this.id = id;

11. this.name = name;

12. this.age = age;

13. }

14. public int getId() {

15. return id;

16. }

17. public void setId(int id) {

18. this.id = id;

19. }

20. public String getName() {

21. return name;

22. }

23. public void setName(String name) {

24. this.name = name;

25. }

26. public int getAge() {

27. return age;

28. }

29. public void setAge(int age) {

30. this.age = age;

31. }

32. @Override

33. public String toString() {

34. return "User [age=" + age + ", id=" + id + ", name=" + name + "]";

35. }

36. }

数据库操作DBOpenHelper.java：

Java代码

1. package com.yaku.db;

3. import android.content.Context;

4. import android.database.sqlite.SQLiteDatabase;

5. import android.database.sqlite.SQLiteOpenHelper;

7. public class DBOpenHelper extends SQLiteOpenHelper {

8. private static final String DBNAME = "yaku.db"; //数据库名称

9. private static final int DBVER = 1;//数据库版本

10.

11. public DBOpenHelper(Context context) {

12. super(context, DBNAME, null, DBVER);

13. }

14.

15. @Override

16. public void onCreate(SQLiteDatabase db) {

17. String sql = "CREATE TABLE user (userid integer primary key autoincrement, name varchar(20), age integer)";

18. db.execSQL(sql);//执行有更改的sql语句

19. }

20.

21. @Override

22. public void onUpgrade(SQLiteDatabase db, int arg1, int arg2) {

23. db.execSQL("DROP TABLE IF EXISTS user");

24. onCreate(db);

25. }

26.

27. }

对外共享处理类ContentProviderUser.java：

Java代码

1. package com.yaku.ContentProvider;

3. import com.yaku.db.DBOpenHelper;

5. import android.content.ContentProvider;

6. import android.content.ContentUris;

7. import android.content.ContentValues;

8. import android.content.UriMatcher;

9. import android.database.Cursor;

10. import android.database.sqlite.SQLiteDatabase;

11. import android.net.Uri;

12.

13. public class ContentProviderUser extends ContentProvider {

14. private DBOpenHelper dbOpenHelper;

15. //常量UriMatcher.NO_MATCH表示不匹配任何路径的返回码

16. private static final UriMatcher MATCHER = new UriMatcher(UriMatcher.NO_MATCH);

17. private static final int USERS = 1;

18. private static final int USER = 2;

19. static{

20. //如果match()方法匹配content://com.yaku.ContentProvider.userprovider/user路径，返回匹配码为1

21. MATCHER.addURI("com.yaku.ContentProvider.userprovider", "user", USERS);

22. //如果match()方法匹配content://com.yaku.ContentProvider.userprovider/user/123路径，返回匹配码为2

23. MATCHER.addURI("com.yaku.ContentProvider.userprovider", "user/#", USER);//#号为通配符

24. }

25. @Override

26. public int delete(Uri uri, String selection, String[] selectionArgs) {

27. SQLiteDatabase db = dbOpenHelper.getWritableDatabase();

28. int count = 0;

29. switch (MATCHER.match(uri)) {

30. case USERS:

31. count = db.delete("user", selection, selectionArgs);

32. return count;

33. case USER:

34. //ContentUris类用于获取Uri路径后面的ID部分

35. long id = ContentUris.parseId(uri);

36. String where = "userid = "+ id;

37. if(selection!=null && !"".equals(selection)){

38. where = selection + " and " + where;

39. }

40. count = db.delete("user", where, selectionArgs);

41. return count;

42. default:

43. throw new IllegalArgumentException("Unkwon Uri:"+ uri.toString());

44. }

45. }

46.

47. /**

48. * 该方法用于返回当前Url所代表数据的MIME类型。

49. * 如果操作的数据属于集合类型，那么MIME类型字符串应该以vnd.android.cursor.dir/开头

50. * 如果要操作的数据属于非集合类型数据，那么MIME类型字符串应该以vnd.android.cursor.item/开头

51. */

52. @Override

53. public String getType(Uri uri) {

54. switch (MATCHER.match(uri)) {

55. case USERS:

56. return "vnd.android.cursor.dir/user";

57.

58. case USER:

59. return "vnd.android.cursor.item/user";

60.

61. default:

62. throw new IllegalArgumentException("Unkwon Uri:"+ uri.toString());

63. }

64. }

65.

66. @Override

67. public Uri insert(Uri uri, ContentValues values) {

68. SQLiteDatabase db = dbOpenHelper.getWritableDatabase();

69. switch (MATCHER.match(uri)) {

70. case USERS:

71. long rowid = db.insert("user", "name", values);

72. Uri insertUri = ContentUris.withAppendedId(uri, rowid);//得到代表新增记录的Uri

73. this.getContext().getContentResolver().notifyChange(uri, null);

74. return insertUri;

75.

76. default:

77. throw new IllegalArgumentException("Unkwon Uri:"+ uri.toString());

78. }

79. }

80.

81. @Override

82. public boolean onCreate() {

83. this.dbOpenHelper = new DBOpenHelper(this.getContext());

84. return false;

85. }

86.

87. @Override

88. public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,

89. String sortOrder) {

90. SQLiteDatabase db = dbOpenHelper.getReadableDatabase();

91. switch (MATCHER.match(uri)) {

92. case USERS:

93. return db.query("user", projection, selection, selectionArgs, null, null, sortOrder);

94. case USER:

95. long id = ContentUris.parseId(uri);

96. String where = "userid = "+ id;

97. if(selection!=null && !"".equals(selection)){

98. where = selection + " and " + where;

99. }

100. return db.query("user", projection, where, selectionArgs, null, null, sortOrder);

101. default:

102. throw new IllegalArgumentException("Unkwon Uri:"+ uri.toString());

103. }

104. }

105.

106. @Override

107. public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {

108. SQLiteDatabase db = dbOpenHelper.getWritableDatabase();

109. int count = 0;

110. switch (MATCHER.match(uri)) {

111. case USERS:

112. count = db.update("person", values, selection, selectionArgs);

113. return count;

114. case USER:

115. long id = ContentUris.parseId(uri);

116. String where = "userid = "+ id;

117. if(selection!=null && !"".equals(selection)){

118. where = selection + " and " + where;

119. }

120. count = db.update("user", values, where, selectionArgs);

121. return count;

122. default:

123. throw new IllegalArgumentException("Unkwon Uri:"+ uri.toString());

124. }

125. }

126. }

单元测试类（在另一个应用中）：

Java代码

1. package com.yaku.ContentProvider;

3. import android.content.ContentResolver;

4. import android.content.ContentValues;

5. import android.database.Cursor;

6. import android.net.Uri;

7. import android.test.AndroidTestCase;

8. import android.util.Log;

10. /**

11. * 对ContentProvider工程中的ContentProviderActivity进行单元测试

12. */

13. public class ContentProviderActivityTest extends AndroidTestCase {

14. private static final String TAG = "ContentProvider";

15. //往内容提供者添加数据

16. public void testInsert() throws Throwable{

17. ContentResolver contentResolver = this.getContext().getContentResolver();

18. Uri insertUri = Uri.parse("content://com.yaku.ContentProvider.userprovider/user");

19. ContentValues values = new ContentValues();

20. values.put("name", "道长");

21. values.put("age", 86);

22. Uri uri = contentResolver.insert(insertUri, values);

23. Log.i(TAG, uri.toString());

24. }

25.

26. //更新内容提供者中的数据

27. public void testUpdate() throws Throwable{

28. ContentResolver contentResolver = this.getContext().getContentResolver();

29. Uri updateUri = Uri.parse("content://com.yaku.ContentProvider.userprovider/user/1");

30. ContentValues values = new ContentValues();

31. values.put("name", "青眉道长");

32. contentResolver.update(updateUri, values, null, null);

33. }

34.

35. //从内容提供者中删除数据

36. public void testDelete() throws Throwable{

37. ContentResolver contentResolver = this.getContext().getContentResolver();

38. Uri deleteUri = Uri.parse("content://com.yaku.ContentProvider.userprovider/user/1");

39. contentResolver.delete(deleteUri, null, null);

40. }

41.

42. //获取内容提供者中的数据

43. public void testFind() throws Throwable{

44. ContentResolver contentResolver = this.getContext().getContentResolver();

45. Uri selectUri = Uri.parse("content://com.yaku.ContentProvider.userprovider/user");

46. Cursor cursor = contentResolver.query(selectUri, null, null, null, "userid desc");

47. while(cursor.moveToNext()){

48. int id = cursor.getInt(cursor.getColumnIndex("userid"));

49. String name = cursor.getString(cursor.getColumnIndex("name"));

50. int age = cursor.getInt(cursor.getColumnIndex("age"));

51. Log.i(TAG, "id="+ id + ",name="+ name+ ",age="+ age);

52. }

53. }

54.

55. }

监听数据的变化：

Java代码

1. <span style="font-size: medium;">package com.yaku.ContentProvider;

3. import android.content.ContentResolver;

4. import android.content.ContentValues;

5. import android.database.Cursor;

6. import android.net.Uri;

7. import android.test.AndroidTestCase;

8. import android.util.Log;

10. /**

11. * 监听数据变化

12. */

13. public class OtherContentProviderTest extends AndroidTestCase {

14. private static final String TAG = "OtherContentProvider";

15.

16. @Override

17. public void onCreate(Bundle savedInstanceState) {

18. super.onCreate(savedInstanceState);

19. setContentView(R.layout.main);

20.

21. Uri insertUri = Uri.parse("content://com.yaku.ContentProvider.userprovider/user");

22. ContentResolver contentResolver = this.getContentResolver();

23. //对指定uri进行监听，如果该uri代表的数据发生变化，就会调用PersonObserver中的onChange()

24. contentResolver.registerContentObserver(insertUri, true, new PersonObserver(new Handler()));

25. }

26.

27. private final class PersonObserver extends ContentObserver{

28. public PersonObserver(Handler handler) {

29. super(handler);

30. }

31.

32. @Override

33. public void onChange(boolean selfChange) {

34. ContentResolver contentResolver = getContentResolver();

35. Uri selectUri = Uri.parse("content://com.yaku.ContentProvider.userprovider/user");

36. Cursor cursor = contentResolver.query(selectUri, null, null, null, "userid desc");

37. while(cursor.moveToNext()){

38. int id = cursor.getInt(cursor.getColumnIndex("userid"));

39. String name = cursor.getString(cursor.getColumnIndex("name"));

40. int age = cursor.getInt(cursor.getColumnIndex("age"));

41. Log.i(TAG, "id="+ id + ",name="+ name+ ",age="+ age);

42. }

43. }

44. }

45. }

《完》

本文链接

C#面向对象设计模式第十三讲：Proxy 代理模式（结构型模式）

2011-12-29T09:43:00Z

（根据MSDN Webcast 相关课程整理）

直接与间接：

对于复杂的系统，我们常常在使用时添加一个中间层，从而屏蔽一些不常用的功能，或简化一些常用功能等，从而达到用简单灵活的方法满足特定的需要的目的。

如：A访问B时，每访问一次B，就需要调用一次B对象，由于B对象的复杂性，调用开销较大，尤其是B处于分布式应用当中时。另一方面，直接调用复杂的对象，暴露了过多的A不需要的接口，造成不安全性。

加是中间层C以后，简化了B的接口与复杂性，使得A对C的访问简单灵活安全， A对资源的访问也不一定需要直接连接到B，从而无关分布式访问细节。

实例：最早的计算机操作员直接和底层硬件打交道，操作十分复杂；后果，人们设计了操作系统，将计算机底层硬件操作的复杂性于以屏蔽，并帮助我们自动管理了内存，CPU等资源，大大简化了操作的复杂性。

示例：

跨国公司人力管理系统中，员工信息存放在公司总部的服务器上，而运行于国外分部的HR系统如果如何处理这种情况呢？

接口屏蔽了部分功能。

代理类实现了接口功能，并采用SOAP方法调用了服务器上的对象。

《完》

本文链接

C#面向对象设计模式第十二讲：Flyweight 享元模式（结构型模式）

2011-12-29T08:29:00Z

（根据MSDN Webcast 相关课程整理）

面向对象很好的解决了系统抽象的问题，同是不会损害系统的性能。但是在某些特殊应用中，由于对象的数量太大，采用面向对象会给系统带来难以承受的内在开销。

比如：图形应用中的图元等对象，字处理软件中的字符对象等。

如果采用纯粹对方案的问题在于大量细粒度的对象会很快充斥在系统中，从而带来很高的运行代价。这时候，就应该考虑采用享元模式来处理问题。

GoF：运用共享技术处理大量细粒度对象。

采用享元模式设计思想，将重复的Font对象共享出来：

也可以将Font对象封装成属性来做。

Flyweight模式采用共享的方法，解决了倍乘对象带来的系统资源与性能的开销压力的问题。

<完>

本文链接

Android应用程序四种数据存取方法总结

2011-12-28T08:25:00Z

1，采用Shared Preferences：

一句话实现保存Android应用程序配置信息：

保存：getPreferences(Activity.MODE_PRIVATE).edit().putString(strKey,strValue).commit();

读取：strValue=getPreferences(Activity.MODE_PRIVATE).edit().getString(strKey);

注：应用内不同Activity之间的配置数据共享使用getSharedPreferences()。

2，采用File：

Files 数据存储主要是使用 Properties 并配合 FileInputStream或者FileOutputStream对文件写入操作。

保存：

FileOutputStream stream=this.openFileOutput(FileName, Context.MODE_PRIVATE);

new Properties().put(strKey,strValue).store(stream, "");

读取：

FileInputStream stream =this.openFileInput(FileName);

strValue=String.valueOf(new Properties().load(stream).getProperty(strKey));

注：采用 Properties的setProperty()方法，可以将键值对打包，最后调用storeXXX方法写入文件。

3，采用网络空间：(略)

4，采用SQLite数据库：

A,SQLite预备知识：

默认数据库路径：data/data/myPackage/databases/

打开数据库：sqlite3 dbName

操作：.help 帮助；.table 查看所有表

每一句Sql语句结束都需要分号;

B,JDBC驱动程序：

Class.forName("org.sqlite.JDBC");

Connection conn = DriverManager.getConnection("jdbc:sqlite:filename"); //filename为你的SQLite数据名称

C,使用SQLiteOpenHelper操作数据库：

获得数据库实例：

getReadableDatabase()获得可读的SQLiteDatabase

getWritableDatabase() 获得可写的SQLiteDatabase

SQLiteOpenHelper子类中需要重写的常用事件：

onCreate(SQLiteDatabase)

onDowngrade(SQLiteDatabase db, int oldVersion, int newVersion)

onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion)

封装的DBHelp类，实现对数据库的操作：

public class DBHelp extends SQLiteOpenHelper {

public DBHelp(Context context, String name, CursorFactory factory,

int version) {

super(context, name, factory, version);

}

@Override

public void onCreate(SQLiteDatabase db) {

db.execSQL(createTableSQL); // 执行SQL 需要使用execSQL（）

｝

@Override

public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {

｝

@Override

public void onOpen(SQLiteDatabase db) {

｝

InsertData()

UpdateData()

DeleteData()

rawQuery()

query()

｝

创建并打开数据库：

SQLiteDatabase db = new DBHelp(SQLiteActivity.this).getReadableDatabase();

添加数据：

DBHelp dbHelp = new DBHelp(SQLiteActivity.this);

SQLiteDatabase db = dbHelp.getWritableDatabase();

ContentValues contentValues = new ContentValues();

contentValues.put("sName", txtName.getText().toString());

contentValues.put("sSex", "男");

dbHelp.InsertData(db, contentValues)；

修改数据：

DBHelp dbHelp = new DBHelp(SQLiteActivity.this);

SQLiteDatabase db = dbHelp.getWritableDatabase();

ContentValues contentValues = new ContentValues();

contentValues.put("sName", txtsName.getText().toString());

String whereClause = "sid=?"; //要修改数据的条件值用？占位符

String[] whereArgs = new String[]{txtsID.getText().toString()};

dbHelp.UpdateData(db, contentValues, whereClause, whereArgs)；

删除数据：

DBHelp dbHelp = new DBHelp(SQLiteActivity.this);

SQLiteDatabase db = dbHelp.getWritableDatabase();

String whereClause = "sid=?"; //要删除数据的条件值用？占位符

String[] whereArgs = new String[]{txtID.getText().toString()};

dbHelp.DeleteData(db, whereClause, whereArgs)；

查询数据：

Cursor cur =db.rawQuery(“SELECT * FROM Student WHERE sid=1 AND sname=‘zhangsan'", null);

Cursor cur =db.rawQuery(...)

每一个rawQuery()或query()都会返回一个SQLite数据库Cursor。

操作游标：

通过使用 getCount() 方法得到结果集中有多少记录；

通过 moveToFirst(), moveToNext(), 和 isAfterLast() 方法遍历所有记录；

通过 getColumnNames() 得到字段名；

通过 getColumnIndex() 转换成字段号；

通过 getString()，getInt() 等方法得到给定字段当前记录的值；

通过 requery() 方法重新执行查询得到游标；

通过 close() 方法释放游标资源；

SimpleCursorAdapter：和游标关联，绑定到ListView以呈现数据,前提条件，表中有_id列，并且是主键。

SimpleCursorAdapter simple = new SimpleCursorAdapter(SQLiteActivity.this, android.R.layout.simple_list_item_1, cur, new String[]{"sName","sSex"}, new int[]{android.R.id.text1,android.R.id.text2});

studentList.setAdapter(simple);

当_id不是主键时，先从游标是把数据取出来，然后采用SimpleAdapter来呈现数据：

ArrayList<HashMap<String, Object>> students = new ArrayList<HashMap<String,Object>>();

HashMap<String, Object> hs ;

for (cur.moveToFirst();!cur.isAfterLast();cur.moveToNext()) {

hs = new HashMap<String, Object>();

hs.put("sID", cur.getInt(cur.getColumnIndex("sid")));

hs.put("sName", cur.getString(cur.getColumnIndex("sName")));

hs.put("sSex", cur.getString(cur.getColumnIndex("sSex")));

students.add(hs);

}

SimpleAdapter sim = new SimpleAdapter(SQLiteActivity.this, students, android.R.layout.simple_list_item_1, new String[]{"sName","sSex"}, new int[]{android.R.id.text1,android.R.id.text2});

studentList.setAdapter(sim);

《完》

本文链接

C#面向对象设计模式第十一讲：Facade 外观模式（结构型模式）

2011-12-27T09:42:00Z

（根据MSDN Webcast相关课程整理）

先看以下实例：

左边的方案中客户调用程序与子系统内部的具体实现类具有较多的耦合与交互。显然是不理想的设计方案。随着外部客户程序和各子系统的演化，这种过多的耦合将面临居多变化的挑战。

再看右边的方案，外部客户程序不再直接与子系统内部类直接交互，而是通过一个Façade接口实现内外系统之间的关联，大大降低了系统的耦合性。

GoF：为子系统中的一组接口提供一个一致的界面，Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

平常我们讲的接口不是指特定的Interface，而是指类暴露出来的公有方法。这些方法可以和外界接待交互。

示例：坦克车包含了若干个子系统，如车轮系统，控制系统，引擎系统等等。但通常，我们只需要提供一个统一的操作界面，让驾驶员使用就可以啦，而不需要他去了解各子系统具体的工作方式。

这里我们通过internal关键字来实现子系统的隐藏，而采用组合的方法把各子系统添加到Façade中来，并暴露公有的操作方法供外界调用。

Facade模式更多的是运用于架构层级的设计，优化外界与各子系统之间的耦合关系。

<完>

本文链接

7大排序算法小结

2011-12-27T07:26:00Z

1,快速排序 :

快速排序具有神奇的排序效率，平均状况下它的时间复杂度为Ο(nlogn)，但它通常明显比其他Ο(nlogn)的算法更快。快速排序概括起来三步：找基准，通常为序列首尾元素；与基准比较后左右分区；递归。
Java代码：
public void QuickSort(int[] array )
{
    int i = 0 ;
    int j = array.length - 1;
    int k = array[0];
    while(i != j)
    {
        while(array[j] > k)
        {
            j--;
        }
        int temp = k;
        k = array[j];
        array[j] = temp;
        while (array[i] < k)
        {
            i++;
        }
        int temp1= k;
        k = array[i];
        array[i] = temp1;
    }
}

2,归并排序 :

归并排序采用分治法递归实现，单次排序实现将两个有序序序列合并成一个。步骤为：申请大小为两个已经排序序列之和的空间；设定两个指针分别指向序列的起始位置；比较两个指针处的元素，小的放入空间，并移动指针；重复前一步直到某一指针达到序列尾；将另一序列剩下的所有元素直接复制到合并序列尾；递归。
C语言实现：
void Merge(int *R,int low,int m,int high)
{
    int i=low,j=m+1,p=0;
    int *R1;
    R1=(int *)malloc((high-low+1)*sizeof(int));
    if(!R1) return;
    while(i<=m&&j<=high)
        R1[p++]=(R[i]<=R[j])?R[i++]:R[j++];
    while(i<=m)
        R1[p++]=R[i++];
    while(j<=high)
        R1[p++]=R[j++];
    for(p=0,i=low;i<=high;p++,i++)
        R[i]=R1[p];
}
void MergeSort(int R[],int low,int high)
{
    int mid;
    if(low<high)
    {
        mid=(low+high)/2;
        MergeSort(R,low,mid);
        MergeSort(R,mid+1,high);
        Merge(R,low,mid,high);
    }
}

3,堆排序 :

堆排序，先建一个大顶堆，将堆顶元素与序列中最后一个记录交换，然后重新将它调整为一个大顶堆，再将堆顶记录和第 n-1 个记录交换，如此反复直至排序结束。
大顶堆是一棵任一非叶结点的关键字均不小于其左右孩子(若存在)结点的关键字的完全二叉树
C语言实现：
// array是待调整的堆数组,i是待调整的数组元素的位置,nlength是数组的长度
void HeapAdjust(int array[], int i, int nLength)//本函数功能是：根据数组array构建大根堆
{
    int nChild;
    int nTemp;
    for (nTemp = array[i]; 2 * i + 1 < nLength; i = nChild)
    {
        // 子结点的位置=2*(父结点位置）+ 1
        nChild = 2 * i + 1;
        // 得到子结点中较大的结点
        if (nChild < nLength - 1 && array[nChild + 1] > array[nChild])
            ++nChild;
        // 如果较大的子结点大于父结点那么把较大的子结点往上移动,替换它的父结点
        if (nTemp < array[nChild])
        {
            array[i]= array[nChild];
        }
        else　// 否则退出循环
        {
            break;
        }
        // 最后把需要调整的元素值放到合适的位置
        array[nChild]= nTemp;
    }
}
// 堆排序算法
void HeapSort(int array[], int length)
{
    // 调整序列的前半部分元素,调整完之后第一个元素是序列的最大的元素
    for (int i = length / 2 - 1; i >= 0; --i)
    {
        HeapAdjust(array, i, length);
    }
    // 从最后一个元素开始对序列进行调整,不断的缩小调整的范围直到第一个元素
    for (int i = length - 1; i > 0; --i)
    {
        // 把第一个元素和当前的最后一个元素交换,
        // 保证当前的最后一个位置的元素都是在现在的这个序列之中最大的
        Swap(&array[0], &array[i]);
        // 不断缩小调整heap的范围,每一次调整完毕保证第一个元素是当前序列的最大值
        HeapAdjust(array, 0, i);
    }
}

4,选择排序 :

选择排序简单直观。其原理是：首先在未排序序列中找到最小元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小元素，放到排序序列末尾。以此类推，直到所有元素均排序完毕。
Java语言实现：
void SelectSort(SeqList R)
{
    int i,j,k;//最小关键字所在的位置
    for(i=1;i<n;i++){//做第i趟排序(1≤i≤n-1)
        k=i；
        for(j=i+1;j<=n;j++) //在当前无序区R[j..n]中选key最小的记录R[k]
            if(R[j].key<R[k].key)
                k=j; //k记下目前找到的最小关键字所在的位置
        if(k!=i){ //交换R[i]和R[k]
            R[0]=R[i];R[i]=R[k];R[k]=R[0]; //R[0]作暂存单元
        } //endif
    } //endfor
} //SeleetSort

5,冒泡排序 :

冒泡排序是通过依次比较相邻两元素的大小，若逆序则交换，这样一趟将最大的那个先找出来，然后再对剩下的队列进行下一趟排序直到没有发生交换为完成。
C语言实现：
void bubble_sort(int array[],int n)
{
    int i,j,flag,temp;
    for(i = 0; i < n-1; i++)
    {
        flag = 1;//交换标志
        for(j = 0; j < n-i-1; j++)
        {
            if(array[j] > array[j+1])
            {
            temp = array[j];
            array[j] = array[j+1];
            array[j+1] = temp;
            flag = 0;
        }
    }
}

6,插入排序 :

插入排序，先在待排序列中选择第一个元素，在排序序列中从后至前比较，当先元素大于序列中元素时插入。然后重复以前步骤。
void InsertSort(char array[],unsigned int n)
{
    int i,j;
    int temp;
    for(i=1;i<n;i++)
    {
        temp = array[i];//store the original sorted array in temp
        for(j=i ; j>0 && temp < array[j-1] ; j--)//compare the new array with temp
        {
            array[j]=array[j-1];//all larger elements are moved one pot to the right
        }
        array[j]=temp;
    }
}

7,希尔排序 :

希尔排序是一种分组插入排序算法，它采用缩小增量方法对原序列进行分组，在组内实行直接插入排序直到增量＝1 。增量d的取法：d1<n且避免序列中的值(尤其是相邻的值)互为倍数
C＃语言实现：
public void Shell_Sort(int[] list)
{
    int inc;
    for (inc = 1; inc <= list.Length / 9; inc = 3 * inc + 1) ;
    for (; inc > 0; inc /= 3)
    {
        for (int i = inc + 1; i <= list.Length; i += inc)
        {
            int t = list[i - 1];
            int j = i;
            while ((j > inc) && (list[j - inc - 1] > t))
            {
                list[j - 1] = list[j - inc - 1];
                j -= inc;
            }
            list[j - 1] = t;
        }
    }
}

<完>

本文链接