1、Android应用程序四大组件分别是什么？各个组件所起到的作用是什么？
答：Android开发四大组件分别是：活动(Activity)：用于表现功能。服务(Service)：后台运行服务，不提供界面呈现。广播接收器(BroadcastReceiver)：用于接收广播。内容提供商（ContentProvider）：支持在多个应用中存储和读取数据，相当于数据库。
1） 一般一个Android 应用是由多个Activity 组成的。这多个Activity 之间可以进行相互跳转
2） Service 是android 系统中的一种组件，它跟Activity 的级别差不多，但是他不能自己运行，只能后台运行，并且可以和其他组件进行交互
开启service有两种方式:
1. Context.startService()：Service会经历onCreate -> onStart（如果Service还没有运行，则android先调用onCreate()然后调用onStart()；如果Service已经运行，则只调用onStart()，所以一个Service的onStart方法可能会重复调用多次 ）；stopService的时候直接onDestroy，如果是调用者自己直接退出而没有调用stopService的话，Service会一直在后台运行。该Service的调用者再启动起来后可以通过stopService关闭Service。
2. Context.bindService()：Service会经历onCreate() -> onBind()，onBind将返回给客户端一个IBind接口实例，IBind允许客户端回调服务的方法，比如得到Service运行的状态或其他操作。这个时候把调用者（Context，例如Activity）会和Service绑定在一起，Context退出了，Srevice就会调用onUnbind -> onDestroyed相应退出，所谓绑定在一起就共存亡了 。
3） BroadcastReceiver
在Android 中，Broadcast 是一种广泛运用的在应用程序之间传输信息的机制。而BroadcastReceiver 是对发送出来的Broadcast进行过滤接受并响应的一类组件
4）在Android中，ContentResolver是用来发起Content Provider的定位和访问的。
2、Android应用的目录组织结构，每个文件夹及文件的用途？
1.src：存放所有的*.java源程序。
2.gen：为ADT插件自动生成的代码文件保存路径，里面的R.java将保 存所有的资源ID。
3.assets：可以存放项目一些较大的资源文件，例如：图片、音乐、字体等。
4.res：可以存放项目中所有的资源文件，例如：图片（*.png、*.jpg）、文本等。
5.res/drawable-hdpi：保存高分辨率图片资源，可以使用Resources.getDrawable(id)可以获得资源类型。
6.res/drawable-ldpi：保存低分辩率图片资源，可以使用Resources.getDrawable(id)可以获得资源类型。
7.res/drawable-mdpi：保存中等分辨率图片资源，可以使用Resources.getDrawable(id)可以获得资源类型。
8.res/layout：存放所有的布局文件，主要是用于排列不同的显示组件，在Android程序中要读取此配置。
9.res/values： 存放一些资源文件的信息，用于读取文本资源，在本文件夹之中有一些约定的文件名称。
3、Android中如何进行事件处理？事件源是什么？事件处理类是什么？注册事件监听又是怎么回事？
点击事件监听器的四种写法
方法一：写一个内部类，在类中实现点击事件
1、在父类中调用点击事件
bt_dail.setOnClickListener(new MyButtonListener());
2、创建内部类
private class MyButtonListener implements OnClickListener{
/**
* 当按钮被点击的时候调用
*/
@Override
public void onClick(View v) {
callPhone();
}
} 方法二：使用匿名内部类
bt_dail.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
callPhone();
}
}) 方法三：让activity实现点击接口
1、实现点击接口
public class MainActivity extends Activity <span style="color:#ff0000">implements OnClickListener</span> 2、调用点击事件方法
bt_dail.setOnClickListener(this); 3、实现接口方法
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.bt_dail:
callPhone();
break;
default:
break;
}
} 方法四、在layout XML文件中定义button点击时所调用的方法
1、指定方法
<Button
Android:id="@+id/bt_dail"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:onClick="dailPhone"
android:text="拨打此号码" />2、定义方法
public void dailPhone(View view){
callPhone();
}
4、Activity创建流程是怎样的？
1、首先创造一个项目
2、填好项目的相关属性
3、创建一个Activity类的子类类。Eclipse使用alt+/快捷键可以自动完成父类
4、在rec/layout文件夹里创建布局xml页面 new->others->android->android xml file
5、注册刚才创建的activity子类到AndroidManifest.xml，运用eclisps可以可视化添加，双击AndroidManifest.xml 选择标签application->add->activity ，输入刚才创建 的类名
到此，一个可以使用的activity即创建完成了，下一步是添加UI元素及实现页面响应代码
5、Activity的生命周期是怎样的？
一个Activity在启动的时候会执行onCreate()->onStart()->onResume()，在结束（或离开）的时候会执行onPause()->onStop()->onDestroy(),这就是一个Activity的生命周期。
因此我们要在onCreate方法里把Activity的需要的东西准备好，也就是初始化；在onResume里对Activity里的东西做一些调整；在onPause做一些清理和保存工作(保存持久状态),因为这是最后的
机会，因为onPause完成之前Android不会结束托管Activity类的进程，而之后进程可能被结束。总结一下这几个周期方法的作用：
1 .onCreate():创建Activity调用，用于Activity的初始化，还有个Bundle类型的参数，可以访问以前存储的状态。
2.onStart():Activity在屏幕上对用户可见时调用
3.onResume():Activity开始和用户交互的时候调用，这时该Activity是在Activity栈的顶部。
4.onPause():Activity被暂停时调用，也就是你要对你能看到的这Activity说byebye的时候调用,这里可以做一些清理和保存工作
5.onStop():Activity被停止或者Activity变成不可见时调用
6.onDestroy():Activity被从内存中移除，一般发生在执行finish方法时或者Android回收内存的时候
6、Logcat是干吗用的？
Android日志系统提供了记录和查看系统调试信息的功能。日志都是从各种软件和一些系统的缓冲区中记录下来的，缓冲区可以通过 logcat 命 令来查看和使用.
7、如何实现界面的跳转？
1.显示调用方法
ntent实现页面之间的跳转有两种方式
1、 startActivity(intent)
2、 startActivityForResult(intent,requestCode);
onActivityResult(intrequestCode,int resultCode,Intent data)
setResult(resultCode,data)
2.隐式调用方法（只要action、category、data和要跳转到的Activity在AndroidManifest.xml中设置的匹配就OK
3.跳转到另一个Activity后，当返回时能返回数据
在跳转的Activity端，调用startActivityForResult(intent2, 1),跳转到下一个Activity，其中第一个参数为传入的意图对象，第二个为设置的请求码；
跳转到第二个Activity后，调用setResult(100, intent)方法可返回上一个Activity，其中第一个参数为结果码，第二个为传入的意图对象；
在第一个Activity通过onActivityResult()方法获得返回的数据。
8、跳转时如何携带数据？
①
1、在MainActivity中获得意图对象Intent（意图对象需要在其构造函数中写明上下文，及想要跳转的界面的Class文件）
2、在MainActivity中通过Intent对象的putExtra方法，以键值对的方式存入数据（数据附带在Intent对象中）
3、在MainActivity中通过调用Activity中的startActivity，让事件发生时实现跳转功能
4、在ResultActivity中通过调用上下文的getIntent()方法获得从MainActivity传过来的意图对象（即获得在MainActivity中创建的Intent对象）
5、在ResultActivity中通过获得的Intent对象的getStringExtra()（这里以传字符串为例子，所以用getStringExtra，其他视情况而定）获得以存入键为目标的值
6、数据已从MainActivity传输过来，后续对字符串进行操作。
public class MainActivity extends Activity {
private EditText nameEditText;
private EditText sexEditText;
private EditText ageEditText;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
findView();
FristPut();
}
private void findView() {
nameEditText = (EditText) findViewById(R.id.edit_name);
sexEditText = (EditText) findViewById(R.id.edit_sex);
ageEditText = (EditText) findViewById(R.id.edit_age);
}
private void FristPut() {
Intent intent = new Intent(this,ResultActivity.class);
intent.putExtra("name", nameEditText.getText().toString());
intent.putExtra("sex", sexEditText.getText().toString());
intent.putExtra("age", ageEditText.getText().toString());
this.startActivity(intent);
}
（result代码）
public class ResultActivity extends Activity {
private TextView nameView;
private TextView sexView;
private TextView ageView;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_result);
findView();
FirstGet();
}
private void FirstGet() {
Intent intent = this.getIntent();
String name = intent.getStringExtra("name");
String sex = intent.getStringExtra("sex");
String age = intent.getStringExtra("age");
nameView.setText("姓名是："+name);
sexView.setText("性别是：" + sex);
ageView.setText("年龄是：" + age);
}②
除了简单的传输String方法,我们还可以通过Bundle类的包装来传输
1、在MainActivity中主要的步骤跟第一种方法差不多，只是在放入数据的时候需要先new 一个Bundle对象以做打包用
，把需要传输的数据通过Bundle对象的PutString方法以键值对的方式都放在bundle对象中，然后依旧通过Intent对象
的putExtra方法把Bundle对象传输过去目标界面
2、在ResultActivity中，步骤还是一样，主要是在获得意图对象以后（Intent）通过其getBundleExtra()方法获得传输过来的Bundle对象
，获得Bundle对象后通过其getString方法获得以存入键为目标的值，然后进行进一步的操作
示例代码：
（main）
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
findView();
SecondPut();
}
private void SecondPut() {
Intent intent = new Intent(this,ResultActivity.class);
Bundle bundle = new Bundle();
bundle.putString("name", nameEditText.getText().toString());
bundle.putString("sex", sexEditText.getText().toString());
bundle.putString("age", ageEditText.getText().toString());
intent.putExtra("name", bundle);
this.startActivity(intent);
}③
1、第三种方法是传输一个对象，在Main中把数据都加载在一个实体类对象中（注意此时的实体类必须要序列化及实现Serializable接口或Parcalable接口），
然后依旧通过putExtra把对象传到目标界面
2、在Result中步骤相同，获得对象后通过其get属性方法获得数据
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
findView();
ThirdPut();
}
private void ThridPut() {
//Person是自创的bean类
Intent intent = new Intent(this,ResultActivity.class);
Person person = new Person();
person.setName(nameEditText.getText().toString());
person.setSex(sexEditText.getText().toString());
person.setAge(ageEditText.getText().toString());
intent.putExtra("name", person);
this.startActivity(intent);
}
（Result）
Intent intent = this.getIntent();
Person person = (Person) intent.getSerializableExtra("name");
nameView.setText("姓名是："+person.getName());
sexView.setText("性别是：" +person.getSex());
ageView.setText("年龄是：" +person.getAge());
④
1、第四种方法是通过静态参数来传输，在Main中创建你需要传输的数据，把数据都创建为静态属性（这里需要构造函数让外部实现，默认会有空白构造），
，然后在目标界面通过实例化Main对象。（点）属性获得所需要的数据
⑤
1、第五种方法是通过全局对象传输对象，自定义一个全局对象类继承Application，Application就表示应用程序对象
，在这个类里可定义你要传递的任何数据类型，任意个数据。创建后需要在清单中的Application中注册方可使用
9、LinearLayout的特点是什么
LinearLayout按照垂直或者水平的顺序依次排列子元素，每一个子元素都位于前一个元素之后。如果是垂直排列，那么将是一个N行单列的结构，每一行只会有一个元素，而不论这个元素的宽度为多少；如果是水平排列，那么将是一个单行N列的结构。如果搭建两行两列的结构，通常的方式是先垂直排列两个元素，每一个元素里再包含一个LinearLayout进行水平排列。
LinearLayout中的子元素属性android:layout_weight生效，它用于描述该子元素在剩余空间中占有的大小比例。加入一行只有一个文本框，那么它的默认值就为0，如果一行中有两个等长的文本框，那么他们的android:layout_weight值可以是同为1。如果一行中有两个不等长的文本框，那么他们的android:layout_weight值分别为1和2，那么第一个文本框将占据剩余空间的三分之二，第二个文本框将占据剩余空间中的三分之一。android:layout_weight遵循数值越小，重要度越高的原则。
10、RelativeLayout的特点是什么？
RelativeLayout按照各子元素之间的位置关系完成布局。在此布局中的子元素里与位置相关的属性将生效。例如android：layout_below, android:layout_above等。子元素就通过这些属性和各自的ID配合指定位置关系。注意在指定位置关系时，引用的ID必须在引用之前，先被定义，否则将出现异常。
RelativeLayout里常用的位置属性如下：
android:layout_toLeftOf —— 该组件位于引用组件的左方
android:layout_toRightOf —— 该组件位于引用组件的右方
android:layout_above —— 该组件位于引用组件的上方
android:layout_below —— 该组件位于引用组件的下方
android:layout_alignParentLeft —— 该组件是否对齐父组件的左端
android:layout_alignParentRight —— 该组件是否齐其父组件的右端
android:layout_alignParentTop —— 该组件是否对齐父组件的顶部
android:layout_alignParentBottom —— 该组件是否对齐父组件的底部
android:layout_centerInParent —— 该组件是否相对于父组件居中
android:layout_centerHorizontal —— 该组件是否横向居中
android:layout_centerVertical —— 该组件是否垂直居中
RelativeLayout是Android五大布局结构中最灵活的一种布局结构，比较适合一些复杂界面的布局。
11、ViewGroup和View有关系吗
Android的UI界面都是由View和ViewGroup及其派生类组合而成的。其中，View是所有UI组件的基类，而ViewGroup是容纳这些组件的容器，其本身也是从View派生出来的。
可见，作为容器的ViewGroup可以包含作为叶子节点的View，也可以包含作为更低层次的子ViewGroup，而子ViewGroup又可以包含下一层的叶子节点的View和ViewGroup。事实上，这种灵活的View层次结构可以形成非常复杂的UI布局，开发者可据此设计、开发非常精致的UI界面。
12、何时使用include包含公共的界面，何时选择自定义控件？
在一个项目中我们可能会需要用到相同的布局设计，如果都写在一个xml文件中，代码显得很冗余，并且可读性也很差，所以我们可以把相同布局的代码单独写成一个模块，然后用到的时候可以通过 标签来重用layout代码。
13、ListView控件使用及其优化是怎样的？
ListView的优化：
（前两点都是利用ListView的自身优化机制优化【缓存优化】）
1.利用ListView自身的缓存机制，他会缓存条目中的一个条目item，当listview第一屏显示完成之后，就会出现一个缓存条目，其实就是BaseAdapter里面的public View getView(int position, View convertView, ViewGroup parent)。
2.减少findViewById()的次数，findViewById是一个相对比较耗性能的操作，因为这个操作每次都需要到布局中去查找文件。把item里面的控件封装成一个javaBean，当item条目被加载的时候就去找到对应的控件。
3.利用时间去换取时间，比如开机优化，把一些重要的程序先启动了，启动完系统之后再启动其他程序。
4.利用空间去换取时间，把要获取的数据先加载到内存里面，再处理数据的时候，直接从内存中获取。
例如：减少数据库的频繁打开和关闭和减少查询的次数。
import java.util.List;
5 import android.app.Activity;
6 import android.os.Bundle;
7 import android.os.Handler;
8 import android.os.Message;
9 import android.util.Log;
10 import android.view.LayoutInflater;
11 import android.view.View;
12 import android.view.ViewGroup;
13 import android.view.animation.TranslateAnimation;
14 import android.widget.AdapterView;
15 import android.widget.AdapterView.OnItemClickListener;
16 import android.widget.BaseAdapter;
17 import android.widget.ImageView;
18 import android.widget.ListView;
19 import android.widget.RelativeLayout;
20 import android.widget.TextView;
21
22 import com.android.hzy.mobilesafe.R;
23 import com.android.hzy.mobilesafe.dao.AppLockDao;
24 import com.android.hzy.mobilesafe.domain.AppInfo;
25 import com.android.hzy.mobilesafe.engine.AppInfoService;
26
27 public class AppLockManagerActivity extends Activity {
28
29 protected static final int SUCCESS_GET_APPLICATION = 0;
30 private ListView lv_applockmanager;
31 private RelativeLayout rl_loading;
32 private AppInfoService appInfoService;
33 private List<AppInfo> appInfos;
34
35 private List<String> appLocks; // 程序锁应用集合
36
37 private AppLockManagerAdapter mAdapter;
38 private AppLockDao appLockDao;
39 private Handler mHandler = new Handler(){
40
41 public void handleMessage(Message msg) {
42 switch (msg.what) {
43 case SUCCESS_GET_APPLICATION:
44 appLocks = appLockDao.findAll();
45 mAdapter = new AppLockManagerAdapter();
46 lv_applockmanager.setAdapter(mAdapter);
47 rl_loading.setVisibility(View.GONE);
48 break;
49
50 default:
51 break;
52 }
53 }
54
55 };
56
57 @Override
58 protected void onCreate(Bundle savedInstanceState) {
59 // TODO Auto-generated method stub
60 super.onCreate(savedInstanceState);
61 setContentView(R.layout.app_lock_manager);
62
63 lv_applockmanager = (ListView) findViewById(R.id.lv_applockmanager);
64 rl_loading = (RelativeLayout) findViewById(R.id.rl_loading);
65 appInfoService = new AppInfoService(this);
66
67 new Thread() {
68 public void run() {
69 appInfos = appInfoService.getAppInfos();
70 Message msg = new Message();
71 msg.what = SUCCESS_GET_APPLICATION;
72 mHandler.sendMessage(msg);
73 };
74 }.start();
75
76 appLockDao = new AppLockDao(this);
77
78 lv_applockmanager.setOnItemClickListener(new MyOnItemClickListener());
79 }
80
81 /**********listview条目点击事件*************************/
82 private final class MyOnItemClickListener implements OnItemClickListener{
83
84 @Override
85 public void onItemClick(AdapterView<?> parent, View view, int position,
86 long id) {
87 // TODO Auto-generated method stub
88 // 通过ViewHolder的iv_lock 减少findViewById
89 ImageView iv_lock = ((ViewHolder)view.getTag()).iv_lock;
90 AppInfo appInfo = (AppInfo) mAdapter.getItem(position);
91 // boolean isLockApp = appLockDao.isLockApp(appInfo.getPackagename()); 减少数据库的查询
92 boolean isLockApp = appLocks.contains(appInfo.getPackagename());
93 if (isLockApp) {
94 // 如果有锁 就解锁
95 appLockDao.delete(appInfo.getPackagename());
96 // 解锁需要将集合中带锁应用的移除
97 appLocks.remove(appInfo.getPackagename());
98 iv_lock.setImageResource(R.drawable.unlock);
99 } else {
100 // 如果没有锁 就加锁
101 appLockDao.add(appInfo.getPackagename());
102 // 加锁需要将有锁的集合中添加该应用
103 appLocks.add(appInfo.getPackagename());
104 iv_lock.setImageResource(R.drawable.lock);
105 }
106
107 // 设置动画
108 TranslateAnimation animation = new TranslateAnimation(0, 80, 0, 0);
109 animation.setDuration(300);
110 view.startAnimation(animation);
111 }
112
113 }
114
115 /**
116 * 适配器
117 */
118 public final class AppLockManagerAdapter extends BaseAdapter{
119
120 private LayoutInflater mInflater;
121
122 public AppLockManagerAdapter() {
123 // TODO Auto-generated constructor stub
124 mInflater = getLayoutInflater();
125 }
126
127 @Override
128 public int getCount() {
129 // TODO Auto-generated method stub
130 return appInfos.size();
131 }
132
133 @Override
134 public Object getItem(int position) {
135 // TODO Auto-generated method stub
136 return appInfos.get(position);
137 }
138
139 @Override
140 public long getItemId(int position) {
141 // TODO Auto-generated method stub
142 return position;
143 }
144
145 @Override
146 public View getView(int position, View convertView, ViewGroup parent) {
147 // TODO Auto-generated method stub
148 View view = null;
149 ViewHolder holder = null;
150 if (convertView != null) {
151 view = convertView;
152 holder = (ViewHolder) view.getTag();
153 Log.i("i", " convertView != null 缓存不等于空 使用缓存");
154
155 } else {
156 Log.i("i", " convertView == null 缓存等于空");
157 view = mInflater.inflate(R.layout.app_lock_manager_item, null);
158 holder = new ViewHolder();
159 holder.iv_appicon = (ImageView) view.findViewById(R.id.iv_appicon);
160 holder.tv_appname = (TextView) view.findViewById(R.id.tv_appname);
161 holder.iv_lock = (ImageView) view.findViewById(R.id.iv_lock);
162 view.setTag(holder);
163 }
164 AppInfo appInfo = appInfos.get(position);
165
166 ImageView iv_appicon = holder.iv_appicon;
167 TextView tv_appname = holder.tv_appname;
168 ImageView iv_lock = holder.iv_lock;
169
170 iv_appicon.setImageDrawable(appInfo.getApp_icon());
171 tv_appname.setText(appInfo.getApp_name());
172
173 // boolean isLockApp = appLockDao.isLockApp(appInfo.getPackagename());
174 boolean isLockApp = appLocks.contains(appInfo.getPackagename()); // 此功能优化后 不用每次查询数据库 直接将所有有锁的程序都放入集合中存储
175 if(isLockApp){
176 iv_lock.setImageResource(R.drawable.lock);
177 }else{
178 iv_lock.setImageResource(R.drawable.unlock);
179 }
180
181 return view;
182 }
183
184 }
185
186 static class ViewHolder{
187 ImageView iv_appicon;
188 TextView tv_appname;
189 ImageView iv_lock;
190 }
191 }14、Adapter起到的作用是什么？
一般是针对包含多个元素的View，如ListView，GridView，ExpandableListview，的时候我们是给其设置一个Adapter。Adapter是与View之间提供数据的桥梁，也是提供每个Item的视图桥梁。
15、SharedPreferences存储方式的特点是什么？最终生成的文件是什么格式？
在Android中一共提供了5种数据存储方式，分别为：
（1）Files：通过FileInputStream和FileOutputStream对文件进行操作。
（2）Shared Preferences：常用来存储键值对形式的数据，对系统配置信息进行保存。
（3）Content Providers：数据共享，用于应用程序之间数据的访问。
（4）SQLite：Android自带的轻量级关系型数据库，支持SQL语言，用来存储大量的数据，并且能够对数据进行使用、更新、维护等操作。
（5）Network：通过网络来存储和获取数据。
SharedPreferences是android.content.SharedPreferences包内的一个类，它主要是用来共享程序数据的。
SharedPreferences是以键值对（key-value）的方式来存储数据，它可以存储booleans, floats, ints, longs, and strings这些基本的数据类型。
获取SharedPreferences对象的方法有两种：
getSharedPreferences()
这种方法用于APP中有多个SharedPreferences文件，通过名字来获取SharedPreferences对象；
getPreferences()
这种方法用于Activity中只有一个SharedPreferences文件时，因为只有一个，所以就不必提供名字。
实际应用时，第一种方法用的会更多。
向SharedPreferences中写数据：
通过edit()方法获取SharedPreferences.Editor对象；
调用putXXX()方法，放值，（XXX为基本数据类型）；
调用commit()方法提交放入的值。
最终是以xml方式来保存
16、数据库存储用的是什么？Cursor是什么？如果不会SQL语句怎么办？
SQLite
Cursor 是每行的集合。使用 moveToFirst() 定位第一行。你必须知道每一列的名称。你必须知道每一列的数据类型。Cursor 是一个随机的数据源。所有的数据都是通过下标取得。
18、XML解析技术有哪些？
第一种方式：DOM解析器：
第二种方式：SAX解析器：
第三种方式：PULL解析器：
19、JSON解析又是什么?
JSON的定义：
一种轻量级的数据交换格式，具有良好的可读和便于快速编写的特性。业内主流技术为其提供了完整的解决方案（有点类似于正则表达式 ，获得了当今大部分语言的支持），从而可以在不同平台间进行数据交换。JSON采用兼容性很高的文本格式，同时也具备类似于C语言体系的行为。
package com.jun.json;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.URL;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.util.EntityUtils;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import org.json.JSONTokener;
import android.os.Bundle;
import android.app.Activity;
import android.view.Menu;
import android.widget.TextView;
public class JsonActivity extends Activity {
TextView tvJson=null;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_json);
tvJson=(TextView) findViewById(R.id.showTxt);
jsonOper();
}
private void jsonOper() {
// TODO Auto-generated method stub
String str=connServerForResult("http://bcs.duapp.com/weimeipicture/tes.txt");
parseJsonMulti(str);
}
/解析多个数据的Json
private void parseJsonMulti(String strResult) {
String sb ="";
try {
// JSONObject jsonObject=new JSONObject();
// jsonObject.optJSONObject(strResult);
// System.out.println("Jsons parse error 1");
// JSONArray jsonObjs =jsonObject.getJSONArray("messages");
JSONTokener jsonParser = new JSONTokener(strResult);
JSONObject jsonObject = (JSONObject) jsonParser.nextValue();
JSONArray jsonObjs =jsonObject.getJSONArray("messages");
for(int i = 0; i < jsonObjs.length() ; i++){
JSONObject jsonObj = ((JSONObject)jsonObjs.opt(i)) ;
System.out.println("Jsons parse error 0"+i);
String msg = jsonObj.getString("msg");
sb+= "msg:::"+msg + "\n";
System.out.println(sb);
}
tvJson.setText(sb);
} catch (JSONException e) {
System.out.println("Jsons parse error !!!!");
e.printStackTrace();
}
}
//获取json文本
private String connServerForResult(String strUrl) {
// HttpGet对象
HttpGet httpRequest = new HttpGet(strUrl);
String strResult = "";
try {
// HttpClient对象
HttpClient httpClient = new DefaultHttpClient();
// 获得HttpResponse对象
HttpResponse httpResponse = httpClient.execute(httpRequest);
if (httpResponse.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
// 取得返回的数据
strResult = EntityUtils.toString(httpResponse.getEntity());
// str=new String(str.getBytes("8859_1"),"GB2312");
//tvJson.setText();
}
} catch (ClientProtocolException e) {
tvJson.setText("protocol error");
e.printStackTrace();
} catch (IOException e) {
tvJson.setText("IO error");
e.printStackTrace();
}
try {
strResult=new String(strResult.getBytes("8859_1"),"GB2312");
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return strResult;
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.activity_json, menu);
return true;
}
} 20、XML解析和JSON解析各自的优缺点是什么？
JSON Vs XML
1.JSON和XML的数据可读性基本相同
2.JSON和XML同样拥有丰富的解析手段
3.JSON相对于XML来讲，数据的体积小
4.JSON与JavaScript的交互更加方便
5.JSON对数据的描述性比XML较差
6.JSON的速度要远远快于XML
21、多线程创建的方式有哪些？
1.通过继承Thread类，并改写run方法来实现一个线程
public class MyThread extends Thread {
//继承Thread类，并改写其run方法
private final static String TAG = "My Thread ===> ";
public void run(){
Log.d(TAG, "run");
for(int i = 0; i<100; i++)
{
Log.e(TAG, Thread.currentThread().getName() + "i = " + i);
}
}
}
启动线程：
new MyThread().start(); 2.创建一个Runnable对象
public class MyRunnable implements Runnable{
private final static String TAG = "My Runnable ===> ";
@Override
public void run() {
// TODO Auto-generated method stub
Log.d(TAG, "run");
for(int i = 0; i<1000; i++)
{
Log.e(TAG, Thread.currentThread().getName() + "i = " + i);
}
}
} 启动线程：
// providing a new Thread instance with a Runnable object during its creation.
new Thread(new MyRunnable()).start(); 3.通过Handler启动线程
public class MainActivity extends Activity {
private final static String TAG = "UOfly Android Thread ==>";
private int count = 0;
private Handler mHandler = new Handler();
private Runnable mRunnable = new Runnable() {
public void run() {
Log.e(TAG, Thread.currentThread().getName() + " " + count);
count++;
setTitle("" + count);
// 每3秒执行一次
mHandler.postDelayed(mRunnable, 3000); //给自己发送消息，自运行
}
};
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
// 通过Handler启动线程
mHandler.post(mRunnable); //发送消息，启动线程运行
}
@Override
protected void onDestroy() {
//将线程销毁掉
mHandler.removeCallbacks(mRunnable);
super.onDestroy();
}
} 22、Handler的作用是什么？
简单来说，Handler这个类就是管理某个线程(也可能是进程)的消息队列，比如让Handler处理主线程的消息队列，这样就可以将一些耗时任务放到其他线程之中，待任务完成之后就往主线程的消息队列中添加一个消息，这样Handler的Callback，即handleMessage就会被调用。但是Handler并不是线程安全的，因此官方文档中建议将Handler作为一个静态内部类。
所以Handler只是处理消息，耗时任务放在其他线程。
23.ActivityNotFoundException
没有在Manifest.xml里注册
PermissionDennied
AndroidManifest.xml中加权限
NullPointerException
空指针异常
以上来源于自己平时的笔记，整理，希望可以用于以后查阅
