安卓实习第十天

- SQLite的Dao层编写及调用

SJBDatabaseHelper.java

package com.shijiebang.offlinemap.db.SJBDao;

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;

/**
 * Created by zhangkaiyue on 15/7/27.
 */
public class SJBDatabaseHelper extends SQLiteOpenHelper {

    private static final int VERSION = 1;
    private static final String DBNAME = "search_history.db";
    private static final String CRAETE_SEARCH_HISTORY = "create table search_history ("
            + "id integer primary key autoincrement,"
            + "search text)";

    //自带的构造方法
    public SJBDatabaseHelper(Context context, String name, SQLiteDatabase.CursorFactory factory,
                             int version) {
        super(context, name, factory, version);
    }


    public SJBDatabaseHelper(Context context) {
        this(context, DBNAME, null, VERSION);
    }

    //版本变更时
    public SJBDatabaseHelper(Context context,int version) {
        this(context,DBNAME,null,version);
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        db.execSQL(CRAETE_SEARCH_HISTORY);
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        db.execSQL("drop table if exists search_history");
        onCreate(db);
    }


}

SJBSearchHistoryDao.java

package com.shijiebang.offlinemap.db.SJBDao;

import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.util.Log;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Created by zhangkaiyue on 15/7/28.
 */
public class SJBSearchHistoryDao {

    private SJBDatabaseHelper helper;
    private SQLiteDatabase db;

    public SJBSearchHistoryDao(Context context) {
        helper = new SJBDatabaseHelper(context);
    }

    /**
     * 当Activity中调用此构造方法，传入一个版本号时，系统会在下一次调用数据库时调用Helper中的onUpgrade()方法进行更新
     * @param context
     * @param version
     */
    public SJBSearchHistoryDao(Context context, int version) {
        helper = new SJBDatabaseHelper(context, version);
    }


    public void insert(String str){
        db = helper.getWritableDatabase();
        ContentValues values = new ContentValues();
        values.put("search", str);
        db.insert("search_history", null, values);
        values.clear();
        db.close();
    }

    public List<Map<String,Object>> query(){
        List<Map<String,Object>> list = new ArrayList<Map<String, Object>>();
        Map<String,Object> map;
        db = helper.getWritableDatabase();
        Cursor cursor = db.query("search_history", null, null,null,null,null,"id desc" );
        if(cursor.moveToFirst()){
            do{
                String search = cursor.getString(cursor.getColumnIndex("search"));
                map = new HashMap<String, Object>();
                map.put("search",search);
                list.add(map);
            }while (cursor.moveToNext());
        }
        cursor.close();
        db.close();
        return list;
    }

    public void delete(String str){
        db = helper.getWritableDatabase();
        db.execSQL("delete from search_history where search = '" + str + "'");
        db.close();
    }

    public void deleteAll(){
        db = helper.getWritableDatabase();
        db.execSQL("delete from search_history");
        db.close();
    }

}

调用

String searchContent = etSearch.getText().toString();
SJBSearchHistoryDao dao = new SJBSearchHistoryDao(getApplicationContext());
dao.insert(searchContent);

---

- 单例模式

单例模式（也叫单件模式）的作用就是保证在整个应用程序的生命周期中，任何一个时刻，单例类的实例都只存在一个

单例模式的定义
单例模式保证一个类仅有一个实例，同时这个类还必须提供一个访问该类的全局访问点

Singleton 类

namespace Singleton 
{ 
    public class Singleton 
    { 
        //定义一个私有的静态全局变量来保存该类的唯一实例 
        private static Singleton singleton;

        /// <summary> 
        /// 构造函数必须是私有的 
        /// 这样在外部便无法使用 new 来创建该类的实例 
        /// </summary> 
        private Singleton() 
        { 
        }

       /// <summary> 
        /// 定义一个全局访问点 
        /// 设置为静态方法 
        /// 则在类的外部便无需实例化就可以调用该方法 
        /// </summary> 
        /// <returns></returns> 
        public static Singleton GetInstance() 
        { 
            //这里可以保证只实例化一次 
            //即在第一次调用时实例化 
            //以后调用便不会再实例化 
            if (singleton == null) 
            { 
                singleton = new Singleton(); 
            } 
            return singleton; 
        } 
    } 
}

客户端代码

using System;

namespace SingletonTest 
{ 
    class Program 
    { 
        static void Main(string[] args) 
        { 
            Singleton.Singleton singletonOne = 
                Singleton.Singleton.GetInstance(); 
            Singleton.Singleton singletonTwo = 
                Singleton.Singleton.GetInstance();

            if (singletonOne.Equals(singletonTwo)) 
            { 
                Console.WriteLine("singletonOne 和 singletonTwo 代表的是同一个实例"); 
            } 
            else 
            { 
                Console.WriteLine("singletonOne 和 singletonTwo 代表的是不同一个实例"); 
            }

            Console.ReadKey(); 
        } 
    } 
}

单例模式的特点：

首先，单例模式使类在程序生命周期的任何时刻都只有一个实例，

然后，单例的构造函数是私有的，外部程序如果想要访问这个单例类的话，

必须通过 GetInstance（）来请求（注意是请求）得到这个单例类的实例。

详见http://www.cnblogs.com/BoyXiao/archive/2010/05/07/1729376.html?login=1