Android详细学习笔记第一季

一、Android学习第一天——环境搭建
Android 开发环境的搭建
环境搭建需要①Android SDK ②JDK ③eclipse
环境搭建开始：
㈠将Android SDK与JDK解压，最好路径中不要出现汉字，然后配置环境变量，方便命令行操作
㈡为eclipse(3.4.1)安装开发Android插件——Android ADT
Help-->Install New Software
输入：https:///android/eclipse
便会自动检测出所需要安装的东西，点击install即可。

㈢重启eclipse，进行Android SDK的配置。

Windows-->Preferences-->Android
找到你解压的Android SDK的路径即可。

㈣新建一个Android Project来验证平台是否搭建成功。

注:我上面步骤走下来之后发现我在运行程序时，没有Android Virtual Devices(AVD)的选项。

这时可以在Windows-->Android SDK Manager中找到你所需要安装版本，进行安装。

搭建过程还是比较顺利，加油~
二、Android学习第二天——初识Activity
昨天程序搭建成功以后，就可以开发跟运行Android应用程序了，因为Activity是开发中不可或缺的组成部分,所以要对Activity有所认识。

以下两点是需要注意的：（个人总结）
1.凡是覆写得方法，在方法体中的第一行一定是super.XXX()，一定要先调用
父类里的相应方法做必要的事情，再根据自己的需求去写其他的代码。

2.如果是从头学习安卓开发，不一定要开发最新的版本，可以在较低版本（2.
3.3）
下进行开发，然后在高版本(4.0)下进行编译与运行，这样可以提高代码的
适应能力，可以兼容高级版本。

下面对我今天的学习进行个小结：
首先Android的四个重要部分①Activity——形象点就是一个应用程序的门面，我们在手机上看到的图形界面
②Intent——它就像一个搬用工，用于Activity之间传递数据，就像请求
③Service——这个是不可见的，是为整个应用程序提供服务支持的底层
④Content Provider——为应用程序提供数据的接口
上面的描述我自己感觉也比较抽象，今天专门研究了Activity，终于守得云开见月明：首先进行以下学习之前需要对Android的工程项目目录有一个总体的了解：
自己总结：
src下是我们自己写得程序；
gen下是我们创建程序时系统自动生成的，切忌勿修改
assets是一个资源库，与res的区别是不会自动在R.java中自动生成id
res是一个资源库，与assets不同的是，每增加一个资源（图片等），会自动在R.java 中生成对应的id
layout用于存放布局文件，用来控制Activity的显示格局
string.xml中存放的一个一个键值对，Activity可以对其进行提取
AndroidManifest.xml是系统比较重要的一个文件，存放Activity的注册信息，每生成一个Activity就应该在这里注册一个。

以上是大概的叙述，不知道表述的清不清楚
Activity学习笔记~~~
•Activity初步介绍
（自己总结）Activity是一个可见的，用于用户跟应用程序交互，可放置多个控件的一个容器。

自己感觉这个Activity的概念就像是我们开发网站的一个页面，也是一个容器，只不过载体不同，一个电脑上面看，一个手机上看而已。

•Activity注意事项，自己总结
一个Activity是一个java类，并且一定要继承Activity类。

当一个Activity第一运行时，就会运行onCreate（）方法，所以要覆写这个方法。

每一个Activity都需要在AndroidManifest.xml中进行配置。

为Activity添加必要控件（部分控件）的方法：在布局文件main.xml中进行添加，此时R.java会自动为该控件生成一个唯一的id，这时在Activity中就可以通过findViewById(R.id.XXX)进行调用啦~~~ 然后你就可以做任何你想做的事情~~~
对有面向对象语言基础的人来说，一看就明白，代码就不用贴啦
•Activity与Intent
形象点来说，Intent就是Activity之间的桥梁，当然也可以是其他的桥梁。

今天我只学到了两个Activity之间通过Intent对象来传递数据。

Intent是一个对象，并且包含一组信息①Component name——指定要传递到哪个Activity
②Action——指定另一个Activity要做什么
③Data——传送的数据
④Categorty
⑤Extras——键值对，也是用来存储数据进行传递
⑥Flags
这里需要注意的是，这互相传递的Activity不一定非要在同一个项目工程内。

•四种基本控件的使用
①TextView②EditText③Button④Menu
具体的添加方法很简单，这里就不做演示啦，明儿上图上程序~~~
这里需要注意的是Menu的添加方法与其他三个有所不同：
其他三个控件都是在对应的布局文件中进行添加，而添加Menu需要在Activity中覆写一个方法——onCreateOptionMenu(Menu menu),这样一个菜单就被创建，但是要实现功能，则需要覆写另一个方法——onOptionItemSelected(MenuItem item)为这个菜单中每个item进行功能的编写。

•Activity的生命周期
Activity有七个有关生命周期的函数，分别是：①onCreate
②onStart
③onRestart
④onResume
⑤onPause
⑥onStop
⑦onDestory
这里我只做个总结，具体在什么时候调用什么网上的教程都比我说的清楚
这里我觉得有两点需要注意：
一、当一个程序启动了后三个进程（onPause,onStop,onDestory），就有可能在系统资源不足时被kill掉。

因为手机毕竟不是电脑，内存有限，所以安卓系统会有自己内部的算法来节省自己的资源。

二、onDestory在两种情况下可能被调用，1是在代码中调用了finish()方法，2是当系统资源不足的时候。

与Activity生命周期有必要联系的还有一个——Task
Task说白了就是一个存放Activity的堆栈，所以具有堆栈的特点——后进先出。

咱们在手机中看到的永远是处于堆栈最顶层的Activity，需要注意的是，Task中的堆栈没有排序的功能。

•窗口形态的Activity——这个将是我们在以后开发中使用比较广泛的一种Activity，就类似于弹出框，但是并不会完全遮挡住下层的Activity。

使用窗口形态的Activity非常简单，只需要在AndroidManifest.xml的对应Activity 注册代码中加一个属性：......android:theme="@Android:style/Theme.Dialog" /> 即可喽~~~
明天将要开始的是Activity布局的学习。

其实安卓对于有java基础的人还是比较容易上手的，加油
三、Android学习第三天——Activity的布局初步介绍
今天总结下Activity相关布局的一些知识：
Activity最简单跟常用的布局分为两种：
①LinearLayout -- 线性布局
②TableLayout -- 表格布局
③RelativeLayout -- 相对布局（今后将会频繁的使用到这个布局）
下面来简单总结下前两种（线性/表格）布局当中常用到的一些属性：
①android:id——为指定的控件制定相应的id
②android:text——指定控件中显示的文本内容，这里尽量使用@strings.**
③android:gravity——指定控件中内容的显示位置，如居中等属性
④android:textsize——指定控件中字体的大小，单位pt（磅）等
⑤android:background——指定控件的背景色，注意这里使用的是RGB命名法，如“#aa0000”
⑥android:layout_width——指定控件的宽度
⑦android:layout_height——指定控件的高度
⑧android:padding——指定控件的内边距，注意这里也可以分上下左右分别设置
⑨android:sigleLine——true/false，设置为true，则将控件中的内容在同一行当中进行显示
⑩android:weight——指定每个控件所占的屏幕比例，如果一个屏幕有两个控件，其中一个控件的该值设置为5，另一个设置为2，则第一个控件将占据整个屏幕的5/7，另一个控件则是2/7
当然，我们可以使用布局嵌套的方式来实现更加复杂，更加漂亮的布局样式，比方说LinearLayout中可以再次嵌套任意多的其他布局，TableLayout也是一样，这里就不举例子了，网上一搜一堆的
其实熟悉网页编写，jsp、css之类的对嵌套不会陌生，跟网页编程有异曲同工之妙下面来简单总结下前两种（相对）布局当中常用到的一些属性：
相对布局会依赖于其他控件的位置，相对前两种布局操作会比较复杂。

我们把相对布局中常用的控件分成了几个组，便于记忆
第一组：两个控件上下左右的对齐属性：（通过ID来指定对方控件）
①android:layout_below——将该控件置于指定控件之下
②android:layout_above——将该控件置于指定控件之上
③android:layout_toLeftOf—将该控件的右边缘和指定控件的左边缘对齐
④android:layout_toRightOf——将该控件的左边缘和指定控件的右边缘对齐
第二组：两个控件上下左右的对齐属性：（通过ID来指定对方控件）
⑤android:layout_alignBottom——将该控件的下边缘与指定id的下边缘对齐
⑥android:layout_alignLeft——将该控件的左边缘与指定id的左边缘对齐
⑦android:layout_alignRight——将该控件的右边缘与指定id的右边缘对齐
⑧android:layout_alignTop——将该控件的上边缘与指定id的上边缘对齐
第三组：与父控件对齐的属性：（true/false两个属性值）
⑨android:layout_alignParentLeft——将该控件的左边缘与其父控件的左边缘对齐
⑩android:layout_alignParentRight——将该控件的右边缘与其父控件的右边缘对齐⑾android:layout_alignParentBottom——将该控件的下边缘与其父控件的下边缘对齐⑿android:layout_alignParentTop——将该控件的上边缘与其父控件的上边缘对齐
第四组：居中属性
⒀android:layout_centerInParent——指定控件水平垂直都居中
⒁android:layout_centerHorizontal——指定控件水平居中
⒂android:layout_centerVertical——指定控件垂直居中
这里大家应该会很疑惑，第一组跟第二组对齐看似相同，下面举两个例子：android:layout_toLeftOf
控件一的左边缘与控件二的右边缘对齐android:layout_alignLeft
控件一的左边缘与控件二的左边缘对齐
看出来了吧，这两组属性有本质的区别。

在以后的使用中，大家根据需要选择即可~~~
这些都是口头上之说，如果大家要更深刻的了解这些属性的作用，就自己动手试一试，这里就不举例子了，只为大家做个总结，一遍以后查阅~~~
明儿见喽~
四、Android学习第四天——JAVA基础回顾
这才学习Android的第四天，在程序中已经遇到了JAVA中以前不常用的一些知识点，赶紧回顾复习一下，打下基础
这里就做个简单的小结：
一、匿名内部类
•匿名内部类说白了就是个没有被命名的JAVA类
在以下条件下使用匿名内部类比较适合：
①只用到该类的一个实例时
②类在定义后被马上用到
③类非常小（SUN推荐是在4行代码以下）
④给类命名并不会导致你的代码更容易被理解
在使用匿名内部类时，需要注意：
①匿名内部类不能有构造方法
②匿名内部类不能定义任何静态成员、方法和类
③匿名内部类不能是public、protected、private、static
④只能创建匿名内部类的一个实例
⑤一个匿名内部类一定是在new之后，用其隐含实现一个接口或实现一个类
⑥匿名内部类为局部内部类，所以局部内部类的限制对其都生效
具体的例子大家可以从网上看下，我这里只是大概的总结一下需要注意的东西。

二、线程
•线程说白了就是一个程序中不同的执行路径。

线程跟进程的比较：
①每个进程都有独立的代码跟数据空间（进程的上下文），进程间得切换会有较大的开销
②线程可以看做是轻量级的进程，同一个线程共享代码跟数据空间，每个线程有独立的运行栈和程序计数器（PC），线程切换的开销小
③多进程：在操作系统中能同时运行多个任务（程序）
④多线程：在同一应用程序中有多个顺序流同时执行
new一个新线程类出来一般会使用下面两种方法的其中一个：
一：继承Thread类来创建一个新的线程，并重写run方法
二：实现Runnable方法
这里需要注意的是：
线程启动：Thread.start()
方法调用：run()
这两种方式的区别：其实真正要启动一个新的线程，需要执行start（）方法；run()方法并没有启动一个新的线程，只是在当前线程下，暂停去执行run方法中的方法体，然后再继续执行接下来的程序。

这两种方式的区别在今后也会详加介绍
五、Android学习第四天补充——Android的常用控件
熟悉常用的Android的几个常用控件的使用方法：
一、RadioGroup和RadioButton——单选按钮
二、Checkbox——复选框
三、Toast——提示框，会自动消失
四、ProgressBar——进度条工具
五、ListView——以列表形式将控件显示出来
下面就对这些内容做个详细的解释：
首先我们要注意在布局文件中对控件进行声明不是必须的，这个在以后应用中需要动态生成一些控件的时候，我们就可以在Activity中进行控件声明，这些以后项目中遇到我们再介绍。

•我们先来看RadioGroup与RadioButton的使用方法
先来看看RadioGroup与RadioButton在main.xml中的声明，如下图中代码：
这里RadioGroup与Checkbox所设置监听器的方法与Button的有所不同，这里使用的是匿名内部类，调用回调函数来实现对Radio与Checkbox的监听器的设置。

如下图中代码是为RadioGroup添加监听器：
•我们再来看Checkbox的使用方法
先来看看Checkbox在main.xml中的声明，如下图中代码：
如下图中代码是为Checkbox添加监听器：
•ProgressBar的使用
如下代码为水平进度条的声明方法：
下图为默认进度条的声明方法：
可以一眼看出，style属性的设置决定了进度条的样式。

如下代码即为实现这两个进度条的Activity类——ProgressBarTest.java package mickey.progress;
import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener; import android.widget.Button;
import android.widget.ProgressBar;
public class ProgressBarTest extends Activity {
// 声明变量
private ProgressBar first = null;
private ProgressBar second = null;
private Button button = null;
private int i = 0;
@Override
public void onCreate(Bundle savedInstanceState) { // 这两句一般都要有
super.onCreate(savedInstanceState); setContentView(yout.main);
// 通过findViewById获得控件对象
first = (ProgressBar) findViewById(R.id.first); second = (ProgressBar) findViewById(R.id.second); button = (Button) findViewById(R.id.button);
// 为button设置监听器
button.setOnClickListener(new ButtonListener()); }
// 监听器内部类
class ButtonListener implements OnClickListener {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
if (i == 0) {
// 设置进度条为可见,如果写0的话，不好看，View.VISIBLE 就能让人一看就知道是设置为可见
first.setVisibility(View.VISIBLE);
second.setVisibility(View.VISIBLE);
} else if (i < first.getMax()) {
// 设置进度条的最大值
first.setMax(200);
// 设置进度条的位置
first.setProgress(i);
// 设置第二进度条的位置
first.setSecondaryProgress(i + 10);
// 因为默认的进度条是无法显示进行的状态的，所以second不用设置
} else {
first.setVisibility(View.GONE);
second.setVisibility(View.GONE);
}
i = i + 10;
}
}
}
如下图为运行后的结果：
但是在开发应用程序的时候，比如下载这些功能是不能写在Activity中的，有可能
导致整个Activity长时间无响应或者报错，用户体验较差，所以Handler就应运而生啦~ 以后将会学习到
•在使用ListView的例子中，需要注意这里继承的是Activity的子类ListActivity。

六、Android学习第五天——Handler的使用
注意：有很多功能是不能写在Activity中的，例如说下载或者处理大量的数据等，
如果这类操作写在Activity中，就有可能导致整个Activity无响应甚至报错，这样用户体验就会比较差。

所以此类功能应该独立于Activity，且互不干扰，所以Handler 就应运而生了。

Handler提供了一个异步的消息处理的方案，将具体复杂的操作都放在一个线程中取处理。

创建一个Handler对象的基本步骤如下：
（一）点击一个按钮，调用Handler的post方法，将要执行的线程对象添加到队列
当中去。

（二）将要执行的操作写在线程对象的run（）方法当中。

（三）如果想要循环执行，则可以在run方法内部执行Handler的postDelayed或者post方法，将线程反复加入到队列当中。

下面是使用Handler的一个简单的例子：
package mickey.handler;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
public class HandlerTest extends Activity {
// 声明两个按钮控件
private Button begin = null;
private Button end = null;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(yout.main);
// 根据控件的ID得到代表控件的对象，并为这两个按钮设置相应的监听器
begin = (Button) findViewById(R.id.begin);
begin.setOnClickListener(new StartButtonListener());
end = (Button) findViewById(R.id.end);
end.setOnClickListener(new EndButtonListener());
// 为start按钮设置的监听器
class StartButtonListener implements OnClickListener {
@Override
public void onClick(View v) {
// 无延迟，直接加入消息队列中，此时消息队列中只有此一个线程
// 调用handler的post方法，将要执行的线程对象添加到队列当中去handler.post(updateThread);
}
}
// 为end按钮设置的监听器
class EndButtonListener implements OnClickListener {
@Override
public void onClick(View v) {
handler.removeCallbacks(updateThread);
}
}
// 创建一个Handler对象
Handler handler = new Handler();
// 一个线程类，将要执行的操作写在线程对象的run方法当中
Runnable updateThread = new Runnable() {
@Override
public void run() {
System.out.println("run......");
// 在run方法内发执行postDelayed或者post方法，延迟三秒，将线程加入队列handler.postDelayed(updateThread, 3000);
};
}
但是我们看到了，上面的例子中我们只是调用了线程的run（）方法，并没用调用Thread的start（）方法来重启一个线程，因此，上面这个例子中，实际上我们并没有重启一个新的线程，从始至终Handler都是和Activity在同一线程中的。

所以如果我们在使用Handler时，要重启一个线程，使用Handler.post(Thread thread)只是调用了该线程的run方法，我们只有使用java中重启线程的方法来重启一个新的线程，即调用Thread.start()方法，这儿不再多说
七、Android学习第六天——SQLite与文件下载
•SQLite
SQLite是Android内嵌的一个非常小的关系型数据库。

总结：当我们操作
在学习SQLite当中，遇到两个问题：
（一）如果我们在搭建Android环境成功后，在命令行中输入adb后没有反应，可以按一下操作来做：
第一步：将platform-tools的目录加入path环境变量的配置中；
第二步：将platform-tools下的adb.exe以及两个dll文件拷贝到tools目录下
第三步：重启命令行，输入adb，搞定
（二）结果按照如上配置path变量后，输入adb shell命令后，提示Device not found.
报这个错的原因，原来是因为没有连接到手机所以报错，在开发Android中，是因为Android虚拟机没有运行而报错，我们只要在eclipse中将Android虚拟机运行起来即可访问。

根据mars老师说，SQLite在开发过程中会出现一些比较古怪的问题，所以建议不要再SQLite中存储过多的数据，不要太过于依赖SQLite。

•程序调试
（一）可以适量的加入一些System.out语句，用来检测程序的运行情况
（二）使用日志输入（Log）——推荐使用这种规范的做法
•文件下载
要实现下载文件的功能，一般步骤为：
（一）创建一个HttpURLConnection对象
URL url = new URL("http://......");
HttpURLConnection urlConn = (HttpURLConnection )url.openConnection();
（二）获得InputStream对象
urlConn.getInputStream();
（三）访问网络的权限
android:permission.INTERNET
访问手机SDCARD的步骤：
（一）得到当前设备SD卡的目录
Environment.getExternalStorageDirectory();
（二）访问SD卡的权限
android.permission.WRITE_EXTERNAL_STORAGE
遇到的问题：
当写好下载程序，却怎么也下载不成功，原来是忘记了最最重要的一步：
切忌最后要在Manifest.xml中添加以下两行代码，赋予权限：
<!-- 下面这两句在下载中必不可少，第一个是赋予了下载的权限，第二个是赋予了写入SD卡的权限-->
<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission
android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
八、Android学习第七天——XML文件解析方法
XML文件：extensible markup language
定义：用于标记电子文件使其具有结构性的标记语言，可以用来标记数据、定义数据类型，是一种允许用户对自己的标记语言进行定义的源语言。

解析XML的方式：
•SAX——Simple API for XML，既是一种接口，也是一个软件包
采用的是事件驱动，也就是它解析XML文档并需要解析完整个文档，在解
析过程中，它会判断解析出的当前字符是否符合XML中的某部分，如果符
合则触发事件，如果不符合则触发相应的回调函数。

此回调函数封装在
ContentHandler接口中。

因为ContentHandler被实现后会被强制实现很多
无用方法，故不用此接口，我们继承DefaultHandler类，因为其实现了
ContentHandler中一部分我们需要的方法，省去了一些我们无用的方法哦。

所以选择用这个。

缺点是，如果要使用它去添加或者删除一些内容会比较费劲的。

•DOM——Document Object Model
此种解析方式是把已知的XML文档全部载入到内存中，并将其存储为dom
树，根据dom结点与子结点之间的关系来解析文件，如果文件过大的话，
解析会很耗时而且很耗资源。

这里主要说明下SAX解析XML文件的过程：
（一）创建事件处理程序
（二）创建SAX解析器
（三）将事件处理程序分配给解析器
（四）对文档进行解析，将每个事件发送给处理程序
九、Android学习第八天——广播机制与WIFI网络操作
今天熟悉了Android中的广播机制与WIFI网络的一些基本操作，总结如下：•Android的广播机制
我们知道广播机制中，发送方不会关心接收方时候接收到数据或者如何去处理数据。

这里总结下Android中BroadcastReceiver的注册方法：
（一）在应用程序中进行注册
（二）在Manifest.xml中进行注册
如果在Manifest.xml中进行注册，那么该应用程序无论是开还是关，该应用都会收到广播事件。

例如：监听电池耗电量等。

显而易见，这种注册方法并不是我们想要的。

如果在应用程序中进行注册，就会在Activity可见时进行注册，不可见时就会取消注册。

在Activity中进行注册的代码如下：
注册：registerReceiver(BroadcastReceiver receiver,IntentFilter filter);
取消注册：unregisterReceiver(BroadcastReceiver receiver);
如果一个BroadcastReceiver用于更新UI，那么通常会使用在代码中注册的方法。

•WIFI基本操作
WIFI应该说是Android中比较重要的一块了，用Android系统手机的童鞋们，应该每天都在接触WIFI。

今天熟悉了如何对WIFI网卡进行基本的操作，包括打开，关闭，检测网卡状态等等。

WIFI网卡的状态是有一系列整型常量来表示的，如下:
(一)WIFI_STATE_DISABLED WIFI网卡不可用——1
(二)WIFI_STATE_DISABLING WIFI网卡正在关闭——0
(三)WIFI_STATE_ENABLED WIFI网卡可用状态——3
(四)WIFI_STATE_ENABLING WIFI网卡正在打开——2
(五)WIFI_STATE_UNKNOWN 未知网卡状态——4
大家注意到了，每个状态后我写了一个数字，我们知道这些都是整型常量，所以后面的数字就是这些常量对应的值，如果大家在程序中，输出当前当卡的状态，就会看到这些数值，对应着某种网卡的状态。

操作Android WIFI网卡状态中，比较重要的是操作WIFI网卡需要的权限，这个有很多。

我们在Android API中可以找到Manifest.permission类，就可以看到各种权限了。

这里贴出WIFI的一个例子，WIFI的这个例子只能在真机上面测试，因为模拟器没有WIFI这样的功能。

这里比较重要的有三个文件：
WIFITestActivity.java
main.xml
Manifest.xml
下面来看看这三个文件中的具体代码：
main.xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="/apk/res/android" android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical" >
<TextView
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="WIFI" />
<Button
android:id="@+id/open"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="打开wifi"
/>
<Button
android:id="@+id/close"
android:layout_width="fill_parent"
android:layout_height="wrap_content" android:text="关闭wifi"
/>
<Button
android:id="@+id/check"
android:layout_width="fill_parent"
android:layout_height="wrap_content" android:text="检查wifi状态"
/>
</LinearLayout>
WIFITestActivity.java
package mickey.wifi;
import android.app.Activity;
import android.content.Context;
import .wifi.WifiManager;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener; import android.widget.Button;
import android.widget.Toast;
public class WIFITestActivity extends Activity {
// 三个控件对象
private Button open = null;
private Button close = null;
private Button check = null;
// 我们知道要对网卡进行操作，就需要WifiManager这个类
private WifiManager wifiManager = null;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(yout.main);
// 得到控件对象的实例，并且为他们设置相应的监听器
open = (Button) findViewById(R.id.open);
open.setOnClickListener(new OpenWifiListener());
close = (Button) findViewById(R.id.close);
close.setOnClickListener(new CloseWifiListener());
check = (Button) findViewById(R.id.check);
check.setOnClickListener(new CheckWifiListener());
}
// 为打开网卡按钮设置监听器
class OpenWifiListener implements OnClickListener {
@Override
public void onClick(View arg0) {
// 内部类如果直接使用this的话代表的是它自己，所以要用WIFITestActivity.this // 得到WIFIManager对象
wifiManager = (WifiManager) WIFITestActivity.this
.getSystemService(Context.WIFI_SERVICE);
// setWifiEnabled(true) 打开wifi网卡
wifiManager.setWifiEnabled(true);
// 得到当前网卡的状态，这儿输出的是一个整型常量
System.out.println("当前网卡的状态为：" + wifiManager.getWifiState());
// 弹出一个Toast提示用户当前wifi网卡的状态是什么，记得调用show方法Toast.makeText(WIFITestActivity.this,
"当前wifi网卡的状态为" + wifiManager.getWifiState(),
Toast.LENGTH_SHORT).show();
}
}
// 为关闭网卡按钮设置监听器
class CloseWifiListener implements OnClickListener {
@Override
public void onClick(View arg0) {
// 得到WIFIManager对象
wifiManager = (WifiManager) WIFITestActivity.this
.getSystemService(Context.WIFI_SERVICE);
// 设置网卡不可用
wifiManager.setWifiEnabled(false);
System.out.println("当前网卡的状态为：" + wifiManager.getWifiState()); Toast.makeText(WIFITestActivity.this,
"当前wifi网卡的状态为" + wifiManager.getWifiState(),
Toast.LENGTH_SHORT).show();
}
}
// 为检查网卡状态按钮设置监听器
class CheckWifiListener implements OnClickListener {
@Override
public void onClick(View arg0) {
// 得到WIFIManager对象
wifiManager = (WifiManager) WIFITestActivity.this
.getSystemService(Context.WIFI_SERVICE);
System.out.println("当前网卡的状态为：" + wifiManager.getWifiState()); Toast.makeText(WIFITestActivity.this,
"当前wifi网卡的状态为" + wifiManager.getWifiState(),
Toast.LENGTH_SHORT).show();
}
}
}
Manifest.xml
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="/apk/res/android" package="mickey.wifi"
android:versionCode="1"
android:versionName="1.0" >
<uses-sdk android:minSdkVersion="10" />
<application
android:icon="@drawable/ic_launcher"
android:label="@string/app_name" >
<activity
android:label="@string/app_name"
android:name=".WIFITestActivity" >
<intent-filter >
<action android:name="android.intent.action.MAIN" />
<category android:name="UNCHER" />
</intent-filter>
</activity>
</application>
<!-- 这四个权限一定要有，否则系统不会赋予用户操作网络及网卡的权限-->
<uses-permission android:name="android.permission.CHANGE_NETWORK_STATE"/> <uses-permission android:name="android.permission.CHANGE_WIFI_STATE"/>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/> <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>
</manifest>
然后童鞋们，把基于Android系统的手机用USB数据线连接到电脑，记得把USB
调试打开，然后运行你的程序，就会自动在手机上运行这个程序啦~
十、Android学习第九天——小结
通过这段时间的学习，今晚上来做个小小的总结~~~
最早之前我们就了解到，Android四个重要的部分：
一、Activity ——门面，就是我们看到的用户界面
二、Intent ——在整个应用程序间传送数据
三、Service ——不可见，为整个应用程序提供一个服务支持
四、Content Provider ——为应用程序提供数据的接口
至此，这四个重要的部分我们都已经有了初步的认识。

但是并不是每一个Android
应用程序都需要这四个部分，这不是必需的。

某些时候，我们只需要这四种中的几种组合成我们的应用。

Activity
至此，Activity我们已经很清楚了，需要注意的是Activity的使用，需要在Manifest.xml 中进行注册。

Intent
Android中提供了Intent机制来协助应用间的交互与通讯，Intent负责对应用中一次操作的动作、数据、附加数据进行描述，Android则根据这些Intent的描述，负责找到相应的组件，将Intent传递给调用的组件，并完成对组件的调用。

Intent不仅可用于应用程序之间，也可用于应用程序内部的Activity/Service之间的交互。

因此，Intent在这里起的是一个媒体中介的作用，专门提供组件互相调用的相关信息，实现调用者与被调用者之间的解耦。

理解Intent的关键之一是理解Intent的两种基本用法：
1、显式的Intent——即在构造Intent对象的时候就指定接受者
2、隐式的Intent——在构造Intent对象时，并不知道也并不关心接受者是谁，有利于降低发送者与接受者之间的耦合。

以下是Intent几种常用的用法：
Intent intentOne = new Intent(IntentActivity.this,
ResultActivity.class);
IntentActivity.this.startActivity(intentOne);
------------------------------------------------------------------------
Intent intentTwo = new Intent(IntentActivity.this,
ResultActivity.class);。