如何成为Android高手

要成为Android 高手并非一件容易的事情。并非不少人想象的 可以飞快的写出几行漂亮的代码去解决一些困难的问题 就是Android 高手了。真正的Android 高手须要考虑的问题远远不是写些漂亮的代码就足够的。下面是成为一名真正的Android 高手必须掌握和遵循的一些准则：
1. 学会懒惰
2. 精通Android 体系架构、MVC、常见的设计模式、控制反转（IoC）
3. 编写可重用、可扩展、可维护、灵活性高的代码
4. 高效的编写高效的代码
5. 学会至少一门服务器端开发技术

一：学会懒惰

没搞错吧？居然让程序开发人员学会懒惰？程序开发人员多是世界上最为忙碌的一类人啦！对，没错，学会懒惰！正由于程序开发人员忙碌，正由于程序开发人员可能会在客户无限变化的需求之下没日没夜的加班，因此要学会懒惰，这样，你就能够把更多的时间浪费在美好的事物身上！
如何懒惰：

1. Don’t Reinvent the Wheel（不要重复发明轮子）。
2. Inventing the Wheel ( 发明轮子 )。
3. Don’t Reinvent the Wheel（不要重复发明轮子）。

轮子理论 也即 不要重复发明轮子，这是西方国家的一句谚语，原话是：Don’t Reinvent the Wheel。不要重复发明轮子 意思是企业中任何一项工做实际上都有人作过，咱们所须要作的就是找到作过这件事情的人。拿到软件领域中就是指有的项目或功能，别人已经作过，咱们须要用的时候，直接拿来用便可，而不要从新制造。
Android 号称是首个为移动终端打造的真正开放和完整的移动软件。Android 发布后不久Google 公司就发布了操做系统核心（Kernel）与部分驱动程序的源代码，到目前位置除了Google Map 等Google 公司的核心组件没有开放源代码外，Android 基本完成了彻底的开源，这就极大的促进了Android 的普及和移植。受到Android 开放行为和开源精神的影响，在世界各地，有成千上万的程序员喜欢和别人分享本身的聪明才智和本身编写的代码。你能够在Google 的Android 讨论组或者Google 搜索引擎上搜索到不少优秀的程序代码。这样作并非鼓励你们成天等着让别人为你编写代码，而是你能够“站在伟人的肩膀上”，充分发扬“拿来主义”，聪明地应用别人的程序代码能够节省你大量的时间。
下面笔者为你们介绍几个通用的类，这些类来自笔者平日的收集，若是你能把它们加入到你本身的类库中，早晚你会发现本身在进行Android 开发的时候受益无穷：
1) 从输入流中获取数据并以字节数组返回，这种输入流能够来自Android 本地也能够来自网络。

import java.io.ByteArrayOutputStream;
import java.io.InputStream;
public class StreamTool {
/** * 从输入流获取数据 * @param inputStream * @return * @throws Exception */
    public static byte[] readInputStream(InputStream inputStream) throws Exception {
        byte[] buffer = new byte[1024]; //你能够根据实际须要调整缓存大小
        int len = -1;
        ByteArrayOutputStream outSteam = new ByteArrayOutputStream();
        while( (len = inputStream.read(buffer)) != -1 ){
            outSteam.write(buffer, 0, len);
        }
        outSteam.close();
        inputStream.close();
        return outSteam.toByteArray();
    }
}

2) 经过Android 客户端上传数据到服务器：能够上传简单的表单，也能够方便的上传带有附件的文件，此类远远比Android 自身的HttpClient 更高效、更易于使用：

import java.io.DataOutputStream;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
public class HttpRequester {
/** * 直接经过HTTP 协议提交数据到服务器,实现以下面表单提交功能: * <FORM METHOD=POST ACTION="http://192.168.0.200:8080/ssi/fileload/test.do" enctype="multipart/form-data"> <INPUT TYPE="text" NAME="name"> <INPUT TYPE="text" NAME="id"> <input type="file" name="imagefile"/> <input type="file" name="zip"/> </FORM> * @param actionUrl 上传路径(注：避免使用localhost 或127.0.0.1这样的路径 测试， 由于它会指向手机模拟器， 你可使用http://www.itcast.cn 或 http://192.168.1.10:8080这样的路径测试) * @param params 请求参数key 为参数名,value 为参数值 * @param file 上传文件 */
public static String post(String actionUrl, Map<String, String> params, FormFile[]
files) {
try {
String BOUNDARY = "---------7d4a6d158c9"; //数据分隔线
String MULTIPART_FORM_DATA = "multipart/form-data";
URL url = new URL(actionUrl);
HttpURLConnection conn = (HttpURLConnection)
url.openConnection();
conn.setConnectTimeout(5* 1000);
conn.setDoInput(true);//容许输入
conn.setDoOutput(true);//容许输出
conn.setUseCaches(false);//不使用Cache
conn.setRequestMethod("POST");
conn.setRequestProperty("Connection", "Keep-Alive");
conn.setRequestProperty("Charset", "UTF-8");
conn.setRequestProperty("Content-Type", MULTIPART_FORM_DATA
 * "; boundary=" + BOUNDARY);
StringBuilder sb = new StringBuilder();
for (Map.Entry<String, String> entry : params.entrySet()) {//构建表单
字段内容
sb.append("--");
sb.append(BOUNDARY);
sb.append("\r\n");
sb.append("Content-Disposition: form-data; name=\""+
entry.getKey() + "\"\r\n\r\n");
sb.append(entry.getValue());
sb.append("\r\n");
}
DataOutputStream outStream = new
DataOutputStream(conn.getOutputStream());
outStream.write(sb.toString().getBytes());//发送表单字段数据
for(FormFile file : files){//发送文件数据
StringBuilder split = new StringBuilder();
split.append("--");
split.append(BOUNDARY);
split.append("\r\n");
split.append("Content-Disposition: form-data;name=\""+
file.getFormname()+"\";filename=\""+ file.getFilname() + "\"\r\n");
split.append("Content-Type: "+ file.getContentType()+"\r\n\r\n");
outStream.write(split.toString().getBytes());
if(file.getInStream()!=null){
byte[] buffer = new byte[1024];
int len = 0;
while((len = file.getInStream().read(buffer))!=-1){
outStream.write(buffer, 0, len);
}
file.getInStream().close();
}else{
outStream.write(file.getData(), 0, file.getData().length);
}
outStream.write("\r\n".getBytes());
}
byte[] end_data = ("--" + BOUNDARY + "--\r\n").getBytes();//数据结
束标志
outStream.write(end_data);
outStream.flush();
int cah = conn.getResponseCode();
if (cah != 200) throw new RuntimeException("请求url 失败");
InputStream is = conn.getInputStream();
int ch;
StringBuilder b = new StringBuilder();
while( (ch = is.read()) != -1 ){
b.append((char)ch);
}
outStream.close();
conn.disconnect();
return b.toString();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/** * 提交数据到服务器 * @param actionUrl 上传路径(注：避免使用localhost 或127.0.0.1这样的路径 测试， 由于它会指向手机模拟器， 你可使用http://www.itcast.cn 或 http://192.168.1.10:8080这样的路径测试) * @param params 请求参数key 为参数名,value 为参数值 * @param file 上传文件 */
public static String post(String actionUrl, Map<String, String> params, FormFile
file) {
return post(actionUrl, params, new FormFile[]{file});
}
public static byte[] postFromHttpClient(String path, Map<String, String> params,
String encode) throws Exception{
List<NameValuePair> formparams = new ArrayList<NameValuePair>();// 用
于存放请求参数
for(Map.Entry<String, String> entry : params.entrySet()){
formparams.add(new BasicNameValuePair(entry.getKey(),
entry.getValue()));
}
UrlEncodedFormEntity entity = new UrlEncodedFormEntity(formparams,
"UTF-8");
HttpPost httppost = new HttpPost(path);
httppost.setEntity(entity);
HttpClient httpclient = new DefaultHttpClient();//看做是浏览器
HttpResponse response = httpclient.execute(httppost);//发送post 请求
return StreamTool.readInputStream(response.getEntity().getContent());
}
/** * 发送请求 * @param path 请求路径 * @param params 请求参数key 为参数名称value 为参数值 * @param encode 请求参数的编码 */
public static byte[] post(String path, Map<String, String> params, String encode)
throws Exception{
//String params = "method=save&name="+ URLEncoder.encode(" 老毕",
"UTF-8")+ "&age=28&";//须要发送的参数
StringBuilder parambuilder = new StringBuilder("");
if(params!=null && !params.isEmpty()){
for(Map.Entry<String, String> entry : params.entrySet()){
parambuilder.append(entry.getKey()).append("=")
.append(URLEncoder.encode(entry.getValue(),
encode)).append("&");
}
parambuilder.deleteCharAt(parambuilder.length()-1);
}
byte[] data = parambuilder.toString().getBytes();
URL url = new URL(path);
HttpURLConnection conn = (HttpURLConnection)url.openConnection();
conn.setDoOutput(true);//容许对外发送请求参数
conn.setUseCaches(false);//不进行缓存
conn.setConnectTimeout(5 * 1000);
conn.setRequestMethod("POST");
//下面设置http 请求头
conn.setRequestProperty("Accept", "image/gif, image/jpeg, image/pjpeg, image/pjpeg, application/x-shockwave-flash, application/xaml+xml, application/vnd.ms-xpsdocument, application/x-ms-xbap, application/x-ms-application, application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword, */*");
conn.setRequestProperty("Accept-Language", "zh-CN");
conn.setRequestProperty("User-Agent", "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.2; Trident/4.0; .NET CLR 1.1.4322; .NET CLR 2.0.50727; .NET CLR 3.0.04506.30; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729)");
conn.setRequestProperty("Content-Type",
"application/x-www-form-urlencoded");
conn.setRequestProperty("Content-Length", String.valueOf(data.length));
conn.setRequestProperty("Connection", "Keep-Alive");
//发送参数
DataOutputStream outStream = new
DataOutputStream(conn.getOutputStream());
outStream.write(data);//把参数发送出去
outStream.flush();
outStream.close();
if(conn.getResponseCode()==200){
return StreamTool.readInputStream(conn.getInputStream());
}
return null;
}
}

2，Inventing the Wheel(发明轮子)。
发明轮子？不错，发明轮子！咱们不只要发明轮子，更要成为努力成为世界上发明轮子的主导力量，惟有这样，才能谈的上中华名族软件大业的真正强大。在Android，要发明轮子，就是咱们要主动的是解决一些世界上他人未解决的难题或者创造新的编程框架或者对Android 进行深度的改造以适合本身的业务发展须要。Google 发布了Android 后不久，中国移动便投入了大量的人力和物力，在Android 的基础上建立融入本身业务并开发、封装了新的功能的和框架的OMS，这是Android 中发明轮子的一个很是重要的例子。可能你会说，这发明轮子也太难了吧，别急，咱们慢慢来，开发一个框架特定领域的框架吧！你可能会一脸无辜的说，开发一个框架是说的那么容易吗？固然不是啦。可是也并不是不可能，首先，咱们分析一下框架的魅力的源泉，看看Spring、Struts 等Java EE 框架，在看看.NET框架，固然也能够看看发展的如火如荼、层出不穷的PHP 框架，她们的强大和魅力的源泉都在于：IoC(Inversion of Control)。
Don’t call us, we’ll call you（别找我，我会来找你的）。咱们下面就本身发明一个轮子的模型，实际展现一个框架最初核心的类，让你一饱眼福：
1) 下面的类是文件下载类，支持文件的多线程断点续传，使用该类的便可安全、高效的下载任何类型的二进制文件：

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Properties;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import cn.itcast.service.FileService;
import android.content.Context;
import android.util.Log;
/** * 文件下载器 */
public class FileDownloader {
private Context context;
private FileService fileService;
private static final String TAG = "FileDownloader";
/* 已下载文件大小*/
private int downloadSize = 0;
/* 原始文件大小*/
private int fileSize = 0;
/* 线程数*/
private DownloadThread[] threads;
/* 下载路径*/
private URL url;
/* 本地保存文件*/
private File saveFile;
/* 下载记录文件*/
private File logFile;
/* 缓存各线程最后下载的位置*/
private Map<Integer, Integer> data = new ConcurrentHashMap<Integer, Integer>();
/* 每条线程下载的大小*/
private int block;
private String downloadUrl;//下载路径
/** * 获取线程数 */
public int getThreadSize() {
return threads.length;
}
/** * 获取文件大小 * @return */
public int getFileSize() {
return fileSize;
}
/** * 累计已下载大小 * @param size */
protected synchronized void append(int size) {
downloadSize += size;
}
/** * 更新指定线程最后下载的位置 * @param threadId 线程id * @param pos 最后下载的位置 */
protected void update(int threadId, int pos) {
this.data.put(threadId, pos);
}
/** * 保存记录文件 */
protected synchronized void saveLogFile() {
this.fileService.update(this.downloadUrl, this.data);
}
/** * 构建文件下载器 * @param downloadUrl 下载路径 * @param fileSaveDir 文件保存目录 * @param threadNum 下载线程数 */
public FileDownloader(Context context, String downloadUrl, File fileSaveDir, int
threadNum) {
try {
this.context = context;
this.downloadUrl = downloadUrl;
fileService = new FileService(context);
this.url = new URL(downloadUrl);
if(!fileSaveDir.exists()) fileSaveDir.mkdirs();
this.threads = new DownloadThread[threadNum];
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setConnectTimeout(6*1000);
conn.setRequestMethod("GET");
conn.setRequestProperty("Accept", "image/gif, image/jpeg, image/pjpeg,image/pjpeg, application/x-shockwave-flash, application/xaml+xml,application/vnd.ms-xpsdocument, application/x-ms-xbap, application/x-ms-application, application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword, */*");
conn.setRequestProperty("Accept-Language", "zh-CN");
conn.setRequestProperty("Referer", downloadUrl);
conn.setRequestProperty("Charset", "UTF-8");
conn.setRequestProperty("User-Agent", "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.2; Trident/4.0; .NET CLR 1.1.4322; .NET CLR 2.0.50727; .NET CLR 3.0.04506.30; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729)");
conn.setRequestProperty("Connection", "Keep-Alive");
conn.connect();
printResponseHeader(conn);
if (conn.getResponseCode()==200) {
this.fileSize = conn.getContentLength();//根据响应获取文件大小
if (this.fileSize <= 0) throw new RuntimeException("1没法获知文件大 小");
String filename = getFileName(conn);
this.saveFile = new File(fileSaveDir, filename);/* 保存文件*/
Map<Integer, Integer> logdata = fileService.getData(downloadUrl);
if(logdata.size()>0){
for(Map.Entry<Integer, Integer> entry : logdata.entrySet())
data.put(entry.getKey(), entry.getValue()+1);
}
this.block = this.fileSize / this.threads.length + 1;
if(this.data.size()==this.threads.length){
for (int i = 0; i < this.threads.length; i++) {
this.downloadSize += this.data.get(i+1)-(this.block * i);
}
print("已经下载的长度"+ this.downloadSize);
}
}else{
throw new RuntimeException("2服务器响应错误");
}
} catch (Exception e) {
print(e.toString());
throw new RuntimeException("3链接不到下载路径");
}
}
/** * 获取文件名 */
private String getFileName(HttpURLConnection conn) {
String filename = this.url.toString().substring(this.url.toString().lastIndexOf('/') +
1);
if(filename==null || "".equals(filename.trim())){//若是获取不到文件名称
for (int i = 0;; i++) {
String mine = conn.getHeaderField(i);
if (mine == null) break;
if("content-disposition".equals(conn.getHeaderFieldKey(i).toLowerCase())){
Matcher m =
Pattern.compile(".*filename=(.*)").matcher(mine.toLowerCase());
if(m.find()) return m.group(1);
}
}
filename = UUID.randomUUID()+ ".tmp";//默认取一个文件名
}
return filename;
}
/** * 开始下载文件 * @param listener 监听下载数量的变化,若是不须要了解实时下载的数量,能够设 置为null * @return 已下载文件大小 * @throws Exception */
public int download(DownloadProgressListener listener) throws Exception{
try {
if(this.data.size() != this.threads.length){
this.data.clear();
for (int i = 0; i < this.threads.length; i++) {
this.data.put(i+1, this.block * i);
}
}
for (int i = 0; i < this.threads.length; i++) {
int downLength = this.data.get(i+1) - (this.block * i);
if(downLength < this.block && this.data.get(i+1)<this.fileSize){ //该线
程未完成下载时,继续下载
RandomAccessFile randOut = new
RandomAccessFile(this.saveFile, "rw");
if(this.fileSize>0) randOut.setLength(this.fileSize);
randOut.seek(this.data.get(i+1));
this.threads[i] = new DownloadThread(this, this.url, randOut,
this.block, this.data.get(i+1), i+1);
this.threads[i].setPriority(7);
this.threads[i].start();
}else{
this.threads[i] = null;
}
}
this.fileService.save(this.downloadUrl, this.data);
boolean notFinish = true;//下载未完成
while (notFinish) {// 循环判断是否下载完毕
Thread.sleep(900);
notFinish = false;//假定下载完成
for (int i = 0; i < this.threads.length; i++){
if (this.threads[i] != null && !this.threads[i].isFinish()) {
notFinish = true;//下载没有完成
if(this.threads[i].getDownLength() == -1){//若是下载失败,再
从新下载
RandomAccessFile randOut = new
RandomAccessFile(this.saveFile, "rw");
randOut.seek(this.data.get(i+1));
this.threads[i] = new DownloadThread(this, this.url,
randOut, this.block, this.data.get(i+1), i+1);
this.threads[i].setPriority(7);
this.threads[i].start();
}
}
}
if(listener!=null) listener.onDownloadSize(this.downloadSize);
}
fileService.delete(this.downloadUrl);
} catch (Exception e) {
print(e.toString());
throw new Exception("下载失败");
}
return this.downloadSize;
}
/** * 获取Http 响应头字段 * @param http * @return */
public static Map<String, String> getHttpResponseHeader(HttpURLConnection http) {
Map<String, String> header = new LinkedHashMap<String, String>();
for (int i = 0;; i++) {
String mine = http.getHeaderField(i);
if (mine == null) break;
header.put(http.getHeaderFieldKey(i), mine);
}
return header;
}
/** * 打印Http 头字段 * @param http */
public static void printResponseHeader(HttpURLConnection http){
Map<String, String> header = getHttpResponseHeader(http);
for(Map.Entry<String, String> entry : header.entrySet()){
String key = entry.getKey()!=null ? entry.getKey()+ ":" : "";
print(key+ entry.getValue());
}
}
private static void print(String msg){
Log.i(TAG, msg);
}
public static void main(String[] args) {
/* FileDownloader loader = new FileDownloader(context, "http://browse.babasport.com/ejb3/ActivePort.exe", new File("D:\\androidsoft\\test"), 2); loader.getFileSize();//获得文件总大小 try { loader.download(new DownloadProgressListener(){ public void onDownloadSize(int size) { print("已经下载："+ size); } }); } catch (Exception e) { e.printStackTrace(); }*/
}
}

2) 下面的类是真正支持下载的线程类：

import java.io.InputStream;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.URL;
import android.util.Log;
public class DownloadThread extends Thread {
private static final String TAG = "DownloadThread";
private RandomAccessFile saveFile;
private URL downUrl;
private int block;
/* 下载开始位置*/
private int threadId = -1;
private int startPos;
private int downLength;
private boolean finish = false;
private FileDownloader downloader;
public DownloadThread(FileDownloader downloader, URL downUrl,
RandomAccessFile saveFile, int block, int startPos, int threadId) {
this.downUrl = downUrl;
this.saveFile = saveFile;
this.block = block;
this.startPos = startPos;
this.downloader = downloader;
this.threadId = threadId;
this.downLength = startPos - (block * (threadId - 1));
}
@Override
public void run() {
if(downLength < block){//未下载完成
try {
HttpURLConnection http = (HttpURLConnection)
downUrl.openConnection();
http.setRequestMethod("GET");
http.setRequestProperty("Accept", "image/gif, image/jpeg, image/pjpeg, image/pjpeg, application/x-shockwave-flash, application/xaml+xml, application/vnd.ms-xpsdocument, application/x-ms-xbap, application/x-ms-application, application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword, */*");
http.setRequestProperty("Accept-Language", "zh-CN");
http.setRequestProperty("Referer", downUrl.toString());
http.setRequestProperty("Charset", "UTF-8");
http.setRequestProperty("Range", "bytes=" + this.startPos + "-");
http.setRequestProperty("User-Agent", "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.2; Trident/4.0; .NET CLR 1.1.4322; .NET CLR 2.0.50727; .NET CLR 3.0.04506.30; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729)");
http.setRequestProperty("Connection", "Keep-Alive");
InputStream inStream = http.getInputStream();
int max = 1024 * 1024;
byte[] buffer = new byte[max];
int offset = 0;
print("线程" + this.threadId + "从位置"+ this.startPos+ "开始下 载");
while (downLength < block && (offset = inStream.read(buffer, 0,
max)) != -1) {
saveFile.write(buffer, 0, offset);
downLength += offset;
downloader.update(this.threadId, block * (threadId - 1) +
downLength);
downloader.saveLogFile();
downloader.append(offset);
int spare = block-downLength;//求剩下的字节数
if(spare < max) max = (int) spare;
}
saveFile.close();
inStream.close();
print("线程" + this.threadId + "完成下载");
this.finish = true;
this.interrupt();
} catch (Exception e) {
this.downLength = -1;
print("线程"+ this.threadId+ ":"+ e);
}
}
}
private static void print(String msg){
Log.i(TAG, msg);
}
/** * 下载是否完成 * @return */
public boolean isFinish() {
return finish;
}
/** * 已经下载的内容大小 * @return 若是返回值为-1,表明下载失败 */
public long getDownLength() {
return downLength;
}
}

3) 下面为监听器接口，会实时显示下载的大小，在实际使用的时候建议采用匿名类的方式构建此接口：

public interface DownloadProgressListener {
    public void onDownloadSize(int size);
}

上面的三个文件在一块儿就构建起了一个迷你型的Android 下载框架，这个下载框架能够用于下载任何类型的二进制文件，之后须要下载的时候直接使用便可。其中IoC 很是直接的体现就是DownloadProgressListener ，在使用的时候只须要只须要传入该接口一个实现实例便可自动的获取实时的下载长度。

二：精通Android 体系架构、MVC、常见的设计模式、控制反转（IoC）

1，请看某个著名的IT 公司一则招聘信息的其中一条要求：“熟悉Android 系统架构及相关技术，1年以上实际Android 平台开发经验；”，里面很是明确的说道要求熟练Android系统架构，这从某种程度上说明了对Android 体系架构的理解的重要性，下面咱们看看Android 体系结构图，该图源自Android 的文档：
很明显，上图包含四个主要的层次：

• Linux Kernel：负责硬件的驱动程序、网络、电源、系统安全以及内存管理等功能
• Libraries 和Android Runtime：Libraries：即C/C++函数库部分，大多数都是开放源代码的函数库，例如WebKit，该函数库负责Android 网页浏览器的运行，例如标准的C 函数库Libc、OpenSSL、SQLite 等，固然也包括支持游戏开发2D SGL 和3D OpenGL| ES，在多媒体方面有MediaFramework 框架来支持各类影音和图形文件的播放与显示，
  例如MPEG四、H.26四、MP三、AAC、AMR、JPG 和PNG 等众多的多媒体文件格式。Android 的Runtime 负责解释和执行生成的Dalvik 格式的字节码。
• Application Framework（应用软件架构），Java 应用程序开发人员主要是使用该层封装好的API 进行快速开发。
• Applications:该层是Java 的应用程序层，Android 内置的Google Maps、E-mail、即时通讯工具、浏览器、MP3播放器等处于该层，Java 开发人员开发的程序也处于该层，并且和内置的应用程序具备平等的位置，能够调用内置的应用程序，也能够替换内置的应用程序。

上面的四个层次，下层为上层服务，上层须要下层的支持，调用下层的服务，这种严格分层的方式带来的极大的稳定性、灵活性和可扩展性，使得不一样层的开发人员能够按照规范专心特定层的开发。
Android 应用程序使用框架的API 并在框架下运行，这就带来了程序开发的高度一致性，另外一方面也告诉咱们，要想写出优质高效的程序就必须对整个Application Framework 进行很是深刻的理解。精通Application Framework，你就能够真正的理解Android 的设计和运行机制，也就更可以驾驭整个应用层的开发。
2，Android 的官方建议应用程序的开发采用MVC 模式。何谓MVC？先看看下图
MVC 是Model,View,Controller 的缩写，从上图能够看出MVC 包含三个部分：

• 模型（Model）对象：是应用程序的主体部分，全部的业务逻辑都应该写在该层。
• 视图（View）对象：是应用程序中负责生成用户界面的部分。也是在整个MVC 架构中用户惟一能够看到的一层，接收用户的输入，显示处理结果。
• 控制器（Control）对象：是根据用户的输入，控制用户界面数据显示及更新Model 对象状态的部分，控制器更重要的一种导航功能，想用用户出发的相关事件，交给M 处理。

Android 鼓励弱耦合和组件的重用，在Android 中MVC 的具体体现以下：

1. 视图层（View）：通常采用XML 文件进行界面的描述，使用的时候能够很是方便的引入，固然，如何你对Android 了解的比较的多了话，就必定能够想到在Android 中也可使用JavaScript+HTML 等的方式做为View 层，固然这里须要进行Java 和JavaScript 之间的通讯，幸运的是，Android 提供了它们之间很是方便的通讯实现。
2. 控制层（Controller）：Android 的控制层的重任一般落在了众多的Acitvity 的肩上，这句话也就暗含了不要在Acitivity 中写代码，要经过Activity 交割Model业务逻辑层处理，这样作的另一个缘由是Android 中的Acitivity 的响应时间是5s，若是耗时的操做放在这里，程序就很容易被回收掉。
3. 模型层（Model）：对数据库的操做、对网络等的操做都应该在Model 里面处理，固然对业务计算等操做也是必须放在的该层的。

3，设计模式和IoC(控制反转)
毫无疑问，Android 的之因此可以成为一个开放的气象万千的系统，与设计模式的精妙应用是分不开的，只要你稍微用心观察，就会发如今Android 中处处都是A 设计模式或者设计模式的联合运用，一下的设计模式是您想游刃有余的驾驭Android 必须掌握的：

• Template Method 模式
• Factory Method 模式
• Observer 模式
• Abstract Factory 模式
• Adapter 模式
• Strategy 模式
• State 模式
• Proxy 模式
• Bridge 模式
• Iterator 模式
• Mediator 模式
• Façade 模式
• Composite 模式

Android 框架魅力的源泉在于IoC，在开发Android 的过程当中你会时刻感觉到IoC 带来的巨大方便，就拿Activity 来讲，下面的函数是框架调用自动调用的：

protected void onCreate(Bundle savedInstanceState) ；

不是程序编写者主动去调用，反而是用户写的代码被框架调用，这也就反转了！固然IoC 自己的内涵远远不止这些，可是从这个例子中也能够窥视出IoC带来的巨大好处。此类的例子在Android 随处可见，例如说数据库的管理类，例如说Android 中SAX 的Handler 的调用等。有时候，您甚至须要本身编写简单的IoC 实现，上面展现的多线程如今就是一个说明。

三：编写可重用、可扩展、可维护、灵活性高的代码

Android 应用程序的开发是使用Java 编写，在架构上使用MVC，鼓励组件之间的若耦合。
开发出编写可重用、可扩展、可维护、灵活性高的代码须要经历遵循如下原则：

• “开-闭”原则(OCP)：一个软件实体应当对扩展开放，对修改关闭。这个原则说的是，在设计一个模块的时候，应当使这个模块能够在不被修改的前提下被扩展。换言之，应当能够在没必要修改源代码的状况下改变这个模块的行为。
• 里氏代换原则（LSP）：一个软件实体若是使用的是一个基类的话，那么必定使用于其子类，并且它根本不能察觉出基类对象和子类对象的区别。
• 依赖倒转原则(DIP)：要依赖于抽象,不要依赖于具体。
• 接口隔离原则（ISP）：使用多个专门的接口比使用单一的总接口要好。一个类对另一个类的依赖性应当是创建在最小的接口上的。
• 合成/聚合复用原则（CARP）：又称合成复用原则(CRP),就是在一个新的对象里面使用一些已有的对象，使之成为新对象的一部分；新的对象经过向这些对象的委派达到复用已有功能的目的。简而言之就是：要尽可能使用合成/聚合，尽可能不要使用继承。
• 迪米特法则（LoD）：又称最少知识原则（LKP），就是说一个对象应当对其余对象尽量少的了解。狭义的迪米特法则是指若是两个类没必要彼此直接通讯,那么这两个类就不该当发生直接的相互做用.若是其中一个类须要调用另外一个类的方法的话,能够经过第三者转发这个调用.。广义的迪米特法则是指一个模块设计得好坏的一个重要的标志就是该模块在多大的程度上将本身的内部数据与实现有关的细节隐藏起来。信息的隐藏很是重要的缘由在于,它可使各个子系统之间脱耦,从而容许它们独立地被开发,优化,使用阅读以及修改.。

灵活的使用设计模式能够在面对变幻无穷的业务需求是编写出可重用、可扩展、可维护、灵活性高的代码。
固然，因为Android 是运行在移动设备上的，而移动设备的处理能力是有限的，因此有时间必须在编写可重用、可扩展、可维护、灵活性高的代码与高效的代码之间作出适当的平衡。

四：高效的编写高效的代码

高效快速的编写代码和编写高效率执行的代码不少时候都是对立的死敌，不少时候，你想快速的开发，代码的执行效率每每就会慢下来；你想编写高效的代码，开发速度就会慢下来。
不重复发明轮子和发明新的轮子是高效的编写高效的代码的正确是道路。
关于高效的代码，下面网络的一篇文章，直接转载（不知道是哪位哥们写的）以下：
“现代的手持设备，与其说是电话，更像一台拿在手中的电脑。可是，即便是“最快”的手持设备，其性能也赶不上一台普通的台式电脑。
这就是为何咱们在书写Android 应用程序的时候要格外关注效率。这些设备并无那么快，而且受电池电量的制约。这意味着，设备没有更多的能力，咱们必须把程序写的尽可能有效。
本文讨论了不少能让开发者使他们的程序运行更有效的方法，遵守这些方法，你可使你的程序发挥最大的效力。
对于占用资源的系统，有两条基本原则：

1. 不要作没必要要的事
2. 不要分配没必要要的内存

全部下面的内容都遵守这两个原则。
有些人可能立刻会跳出来，把本节的大部份内容归于“草率的优化”（xing:参见[The Root of All Evil]），不能否认微优化（micro-optimization。xing:代码优化，相对于结构优化）的确会带来不少问题，诸如没法使用更有效的数据结构和算法。可是在手持设备上，你别无选择。
假如你认为Android 虚拟机的性能与台式机至关，你的程序颇有可能一开始就占用了系统的所有内存（xing:内存很小），这会让你的程序慢得像蜗牛同样，更遑论作其余的操做了。
Android 的成功依赖于你的程序提供的用户体验。而这种用户体验，部分依赖于你的程序是响应快速而灵活的，仍是响应缓慢而僵化的。由于全部的程序都运行在同一个设备之上，都在一块儿，这就若是在同一条路上行驶的汽车。而这篇文档就至关于你在取得驾照以前必需要学习的交通规则。若是你们都按照这些规则去作，驾驶就会很顺畅，可是若是你不这样作，
你可能会车毁人亡。这就是为何这些原则十分重要。
当咱们开门见山、直击主题以前，还必需要提醒你们一点：无论VM 是否支持实时（JIT）编译器（xing:它容许实时地将Java 解释型程序自动编译成本机机器语言，以使程序执行的速度更快。有些JVM 包含JIT 编译器。），下面提到的这些原则都是成立的。假如咱们有目标彻底相同的两个方法，在解释执行时foo()比bar()快，那么编译以后，foo()依然会比bar()快。因此不要寄但愿于编译器能够拯救你的程序。
避免创建对象
世界上没有免费的对象。虽然GC 为每一个线程都创建了临时对象池，可使建立对象的代价变得小一些，可是分配内存永远都比不分配内存的代价大。
若是你在用户界面循环中分配对象内存，就会引起周期性的垃圾回收，用户就会以为界面像打嗝同样一顿一顿的。
因此，除非必要，应尽可能避免尽力对象的实例。下面的例子将帮助你理解这条原则：
当你从用户输入的数据中截取一段字符串时，尽可能使用substring 函数取得原始数据的一个子串，而不是为子串另外创建一份拷贝。这样你就有一个新的String 对象，它与原始数据共享一个char 数组。
若是你有一个函数返回一个String对象，而你确切的知道这个字符串会被附加到一个StringBuffer，那么，请改变这个函数的参数和实现方式，直接把结果附加到StringBuffer 中，而不要再创建一个短命的临时对象。
一个更极端的例子是，把多维数组分红多个一维数组。
int 数组比Integer 数组好，这也归纳了一个基本事实，两个平行的int 数组比(int,int)对象数组性能要好不少。同理，这试用于全部基本类型的组合。
若是你想用一种容器存储(Foo,Bar)元组，尝试使用两个单独的Foo[]数组和Bar[]数组，必定比(Foo,Bar)数组效率更高。（也有例外的状况，就是当你创建一个API，让别人调用它的时候。这时候你要注重对API 借口的设计而牺牲一点儿速度。固然在API 的内部，你仍要尽量的提升代码的效率）整体来讲，就是避免建立短命的临时对象。减小对象的建立就能减小垃圾收集，进而减小对用户体验的影响。
使用本地方法
当你在处理字串的时候，不要吝惜使用String.indexOf(),String.lastIndexOf()等特殊实现的方法（specialty methods）。这些方法都是使用C/C++实现的，比起Java 循环快10 到100 倍。
使用实类比接口好
假设你有一个HashMap 对象，你能够将它声明为HashMap 或者Map:

Map myMap1 = new HashMap();
HashMap myMap2 = new HashMap();

哪一个更好呢？
按照传统的观点Map 会更好些，由于这样你能够改变他的具体实现类，只要这个类继承自Map 接口。传统的观点对于传统的程序是正确的，可是它并不适合嵌入式系统。调用一个接口的引用会比调用实体类的引用多花费一倍的时间。
若是HashMap 彻底适合你的程序，那么使用Map 就没有什么价值。若是有些地方你不能肯定，先避免使用Map，剩下的交给IDE 提供的重构功能好了。(固然公共API 是一个例外：一个好的API 经常会牺牲一些性能）
用静态方法比虚方法好
若是你不须要访问一个对象的成员变量，那么请把方法声明成static。虚方法执行的更快，由于它能够被直接调用而不须要一个虚函数表。另外你也能够经过声明体现出这个函数的调用不会改变对象的状态。
不用getter 和setter
在不少本地语言如C++中，都会使用getter（好比：i = getCount()）来避免直接访问成员变量（i = mCount）。在C++中这是一个很是好的习惯，由于编译器可以内联访问，若是你须要约束或调试变量，你能够在任什么时候候添加代码。
在Android 上，这就不是个好主意了。虚方法的开销比直接访问成员变量大得多。在通用的接口定义中，能够依照OO 的方式定义getters 和setters，可是在通常的类中，你应该直接访问变量。
将成员变量缓存到本地
访问成员变量比访问本地变量慢得多，下面一段代码：

for (int i = 0; i < this.mCount; i++)
dumpItem(this.mItems[i]);

最好改为这样：

int count = this.mCount;
Item[] items = this.mItems;
for (int i = 0; i < count; i++)
dumpItems(items[i]);

（使用”this”是为了代表这些是成员变量）
另外一个类似的原则是：永远不要在for 的第二个条件中调用任何方法。以下面方法所示，在每次循环的时候都会调用getCount()方法，这样作比你在一个int 先把结果保存起来开销大不少。

for (int i = 0; i < this.getCount(); i++)
dumpItems(this.getItem(i));

一样若是你要屡次访问一个变量，也最好先为它创建一个本地变量，例如：

protected void drawHorizontalScrollBar(Canvas canvas, int width, int height)
{
     if (isHorizontalScrollBarEnabled()) {
     int size = mScrollBar.getSize(false);
     if (size <= 0) {
         size = mScrollBarSize;
     }
     mScrollBar.setBounds(0, height - size, width, height);

    mScrollBar.setParams(computeHorizontalScrollRange(),computeHorizontalScrollOffset(),computeHorizontalScrollExtent(), false);
     mScrollBar.draw(canvas);
     }
 }

这里有4次访问成员变量mScrollBar，若是将它缓存到本地，4 次成员变量访问就会变成4次效率更高的栈变量访问。
另外就是方法的参数与本地变量的效率相同。
使用常量
让咱们来看看这两段在类前面的声明：

static int intVal = 42;
 static String strVal = "Hello, world!";

必以其会生成一个叫作的初始化类的方法，当类第一次被使用的时候这个方法会被
执行。方法会将42 赋给intVal，而后把一个指向类中常量表的引用赋给strVal。当之后要用到这些值的时候，会在成员变量表中查找到他们。
下面咱们作些改进，使用“final”关键字：

static final int intVal = 42;
 static final String strVal = "Hello, world!";

如今，类再也不需< clinit >方法，由于在成员变量初始化的时候，会将常量直接保存到类文件中。用到intVal 的代码被直接替换成42，而使用strVal 的会指向一个字符串常量，而不是使用成员变量。
将一个方法或类声明为”final”不会带来性能的提高，可是会帮助编译器优化代码。举例说，
若是编译器知道一个”getter”方法不会被重载，那么编译器会对其采用内联调用。
你也能够将本地变量声明为”final”，一样，这也不会带来性能的提高。使用”final”只能使本地变量看起来更清晰些（可是也有些时候这是必须的，好比在使用匿名内部类的时候）（xing:原文是or you have to, e.g. for use in an anonymous inner class）
谨慎使用 foreach
foreach 能够用在实现了Iterable 接口的集合类型上。foreach 会给这些对象分配一个iterator，而后调用hasNext()和next()方法。你最好使用foreach 处理ArrayList 对象，可是对其余集合对象，foreach 至关于使用iterator。
下面展现了foreach 一种可接受的用法：

public class Foo {
     int mSplat;
     static Foo mArray[] = new Foo[27];

     public static void zero() {
         int sum = 0;
         for (int i = 0; i < mArray.length; i++) {
             sum += mArray[i].mSplat;
         }
     }

     public static void one() {
         int sum = 0;
         Foo[] localArray = mArray;
         int len = localArray.length;
         for (int i = 0; i < len; i++) {
             sum += localArray[i].mSplat;
         }
     }

     public static void two() {
         int sum = 0;
         for (Foo a: mArray) {
             sum += a.mSplat;
         }
     }
 }

在zero()中，每次循环都会访问两次静态成员变量，取得一次数组的长度。
retrieves the static field twice and gets the array length once for every iteration through the loop.
在one()中，将全部成员变量存储到本地变量。
pulls everything out into local variables, avoiding the lookups.
two()使用了在java1.5 中引入的foreach 语法。编译器会将对数组的引用和数组的长度保存到本地变量中，这对访问数组元素很是好。可是编译器还会在每次循环中产生一个额外的对本地变量的存储操做（对变量a 的存取）这样会比one()多出4 个字节，速度要稍微慢一些。
综上所述：foreach 语法在运用于array 时性能很好，可是运用于其余集合对象时要当心，由于它会产生额外的对象。
避免使用枚举
枚举变量很是方便，但不幸的是它会牺牲执行的速度和并大幅增长文件体积。例如：

public class Foo {
    public enum Shrubbery { GROUND, CRAWLING, HANGING }}

会产生一个900 字节的.class 文件(Foo$Shubbery.class)。在它被首次调用时，这个类会调用初始化方法来准备每一个枚举变量。每一个枚举项都会被声明成一个静态变量，并被赋值。而后将这些静态变量放在一个名为”$VALUES”的静态数组变量中。而这么一大堆代码，仅仅是为了使用三个整数。
这样:Shrubbery shrub = Shrubbery.GROUND;会引发一个对静态变量的引用，若是这个静态变量是final int，那么编译器会直接内联这个常数。
一方面说，使用枚举变量可让你的API 更出色，并能提供编译时的检查。因此在一般的时候你毫无疑问应该为公共API 选择枚举变量。可是当性能方面有所限制的时候，你就应该避免这种作法了。
有些状况下，使用ordinal()方法获取枚举变量的整数值会更好一些，举例来讲，将：

for (int n = 0; n < list.size(); n++) {
     if (list.items[n].e == MyEnum.VAL_X) // do stuff 1
     else if (list.items[n].e == MyEnum.VAL_Y)// do stuff 2
}

替换为:

int valX = MyEnum.VAL_X.ordinal();
 int valY = MyEnum.VAL_Y.ordinal();
 int count = list.size();
 MyItem items = list.items();
 for (int n = 0; n < count; n++) {
    int valItem = items[n].e.ordinal();
     if (valItem == valX)// do stuff 1
     else if (valItem == valY)// do stuff 2
}

会使性能获得一些改善，但这并非最终的解决之道。
将与内部类一同使用的变量声明在包范围内

public class Foo {
     private int mValue;
     public void run() {
     Inner in = new Inner();
     mValue = 27;
     in.stuff();
 }

 private void doStuff(int value) {
     System.out.println("Value is " + value);
 }

 private class Inner {
     void stuff() {
         Foo.this.doStuff(Foo.this.mValue);
     }
 }}

是，咱们定义了一个内部类(Foo Inner)，它需要访问外部类的私有域变量和函数。这是合法的，并且会打印出我们希望的结果”Valueis27”。问题是在技术上来讲（在幕后）Foo Inner 是一个彻底独立的类，它要直接访问Foo 的私有
成员是非法的。要跨越这个鸿沟，编译器须要生成一组方法：

static int Foo.access$100(Foo foo) {
     return foo.mValue;
 }

 static void Foo.access$200(Foo foo, int value) {
     foo.doStuff(value);
 }

内部类在每次访问”mValue”和”doStuff”方法时，都会调用这些静态方法。就是说，上面的代码说明了一个问题，你是在经过接口方法访问这些成员变量和函数而不是直接调用它们。
在前面咱们已经说过，使用接口方法（getter、setter）比直接访问速度要慢。因此这个例子就是在特定语法下面产生的一个“隐性的”性能障碍。
经过将内部类访问的变量和函数声明由私有范围改成包范围，咱们能够避免这个问题。这样作可让代码运行更快，而且避免产生额外的静态方法。（遗憾的是，这些域和方法能够被同一个包内的其余类直接访问，这与经典的OO 原则相违背。所以当你设计公共API 的时候应该谨慎使用这条优化原则）避免使用浮点数在奔腾CPU 出现以前，游戏设计者作得最多的就是整数运算。随着奔腾的到来，浮点运算处理器成为了CPU 内置的特性，浮点和整数配合使用，可以让你的游戏运行得更顺畅。一般在桌面电脑上，你能够随意的使用浮点运算。
可是很是遗憾，嵌入式处理器一般没有支持浮点运算的硬件，全部对”float”和”double”的运算都是经过软件实现的。一些基本的浮点运算，甚至须要毫秒级的时间才能完成。甚至是整数，一些芯片有对乘法的硬件支持而缺乏对除法的支持。这种状况下，整数的除法和取模运算也是有软件来完成的。因此当你在使用哈希表或者作大量数学运算时必定要当心谨慎。”

5、学会至少一门服务器端开发技术

可能有朋友会问：学习Android 应用程序开发为何还须要学习学会至少一门服务器端开发技术呢？答案以下：一方面Android 号称是首个为移动终端打造的真正开放和完整的移动软件。做为一种移动终端，必须与服务器端结合才能发挥巨大的做用。简言之，须要：云端+云的方式。Android 是为移动互联网时代量身打造的，移动互联网时代的服务模式是“手机终端+互联网络+应用软件”，移动互联网时代应用技术之一的Android 只是用于开发移动终端软件，而服务端技术用于开发互联网络应用，因此将来移动互联网时代软件的主流应用模式将是“手机客户端+互联网络应用服务端”，这种模式要求作移动互联网开发的程序员不但要掌握像Android 这样的手机终端软件技术还要掌握开发互联网络应用的服务器端技术。目前，软件企业广泛存在这样的问题，作移动互联网开发Android 终端软件的程序员不了解web 应用技术，而作web 应用的程序员不了解移动终端技术，这样就致使了客户端与服务端在衔接上出现了问题。目前的现状是：既掌握移动互联网Android 终端技术，又掌握web 应用技术的程序员比较稀缺，随着中国步入移动互联网时代，企业对这种移动互联网时代综合性人才的需求很旺盛。若是不了解web 应用技术，最终会遇到了技术和发展的瓶颈；另外一方面，Google 联合OHA 推出的真正优点之一也在于和和互联网结合，Google 的用意之一也是想开辟新的终端去使用Google 的优点服务。
服务器端开发技术目前主流的有Sun的JavaEE、微软的.NET，开源的以PHP和MySQL为表明的LAMP 体系，咱们该选择哪种呢？从理论上讲，不少人倾向于选择Java EE，毕竟它们都是使用Java 做为开发语言的，可是不少人面对Java EE 众多的框架就望而生畏，其实在学习Java EE 的时候能够从Struts 入手，随着业务的需求逐步深刻。固然，选择微软的.NET 也行，毕竟该技术体系也占有很大市场份额。其实，笔者认为，选择LAMP 能够是会得到最高的“性价比”的，一方面PHP 是如今Web 方面的主流语言，大多数新型的网站尤为是创业性质的网站通常都会选用PHP 做为服务端开发语言，另外一方面，前面也说过，Android 是为移动互联而生的，二者达到了完美的契合。
若是您精通Android，又精通LAMP、Java EE、.NET，请联系笔者：
官方博客： http://www.cnblogs.com/guoshiandroid/