在正式进行
Android测试驱动开发之前，不得不先提一下Android应用架构问题。在传统
软件开发中，MVC架构得到了广泛的应用，然而在Android开发中，很少见应用采用了MVC架构（不要说Android及Widget全部采用的是MVC架构，那是系统的事，我们讲的是应用程序开发），究其原因可能是初期Android应用大多较为简单，没有采用的必要，而后期一直在沿用初期的习惯。但是遇到一些复杂的应用，例如同样的数据在多个Activity中显示，如果数据分散在多个Activity中，那么数据发生更新，很有可能出现数据不一致的情况，尤其是Android应用为节省带宽大量使用缓存的情况下，这种情况更加突出。我所经历的项目中，大部分项目都或多或少存在这个问题。因此，采用MVC架构开发Android应用程序也许是一个值得尝试的方法。所以，在这里我们也会采用MVC架构来做应用程序的开发，虽然我们的架构未必在理论上很完备，也不一定能解决实际应用中的所有问题，但是采用MVC架构的的确确可以提高程序的质量，同时也会使程序的可测试性大大增强。
言归正传，我们现在就开测试驱动开发。
首先建立一个Android工程，例如wkj，然后建立一个Android测试工程如WkjTest，这样就构成了一个Android测试开发的起点，下面就让我们正式开始Android测试驱动开发吧！
我们开始编写第一个
测试用例，由于是空工程，我们首先要测试的是MainActivity正确显示出AppModel所提供的应用名称-维康街。什么？Android创建的工程显示的是Hello World，怎么会是维康街？而且AppModel是个什么东西？细心的读者的这些问题没错，这就是测试驱动开发的
工作模式：先写出失败的测试程序，然后再通过编程来通过这些测试用例。
打开WkjTest工作，创建新类MainActivityTest，并指定该类继承自android.test.ActivityInstrumentationTestCase2，代码如下所示：
package com.bjcic.wkj.test; import com.bjcic.wkj.MainActivity; import android.app.Activity; import android.test.ActivityInstrumentationTestCase2; import android.widget.TextView; public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActivity> { public MainActivityTest() { super(MainActivity.class); } /** * 每个测试用例开始运行前必须执行的代码 */ @Override protected void setUp() throws Exception { super.setUp(); setActivityInitialTouchMode(false); activity = getActivity(); } /** * 每个测试用例运行结束时必须执行的代码 */ @Override protected void tearDown() throws Exception { super.tearDown(); } /** * 测试界面上标题文字为：维康街 */ public void testTemp001() { titleTxtv = (TextView)activity.findViewById(com.bjcic.wkj.R.id.j_titleTxtv); assertEquals(activity.getString(com.bjcic.wkj.R.string.welcome_msg), titleTxtv.getText()); } private Activity activity = null; private TextView titleTxtv = null; } |
在WkjTest工程中，选中MainActivityTest类，点右键，选择Run As....然后选Android JUnit Test，在随后弹出的界面选择测试设备，运行程序后，在Junit视图会显示，执行了test001测试用例，并且该测试用例失败了，这正是我们目前所需要的结果。
另外，注意我们对测试用例的命名，testTemp001，表明是临时性的测试用例。采用这种方式命名的测试用例，表明是在开发过程中使用的临时测试用例，不是用于回归测试中的正式测试用例。
下面开始编写功能性代码，来使这个测试用例通过。
还记得在本文开头处提到的MVC架构吗？现在我们就开始来一步步实现这个MVC架构。我们将Activity当作视图View，View读取Model中数据并显示到界面上，testTemp001这是为了测试这一工作模式。
在Android中怎样来实现一个Model呢？实现Model当然有很多种方式，我在这里采用扩展Application类来当作Model，即定义AppModel并继承Application，这样做的好处是Model不用采用Singleton模式也可以实现单例模式了，而且可以很方便在Activity中获取到。在我们这个最简单的应用中，需要Model中存在welcom_msg信息，这时在MainActivity中才可以通过向Model请求数据并显示在界面中。
AppModel类如下所示：
package com.bjcic.wkj; import android.app.Application; public class AppModel extends Application { // 生命周期方法开始 public void onCreate() { super.onCreate(); welcomeMsg = getString(R.string.welcome_msg); } public void onTerminate() { super.onTerminate(); } // 生命周期方法结束 private String welcomeMsg = null; public String getWelcomeMsg() { return welcomeMsg; } public void setWelcomeMsg(String welcomeMsg) { this.welcomeMsg = welcomeMsg; } } 在MainActivity中添加如下代码： [java] view plaincopy @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); appModel = (AppModel)getApplication(); } @Override public void onResume() { super.onResume(); ((TextView)findViewById(R.id.j_titleTxtv)).setText(appModel.getWelcomeMsg()); } private AppModel appModel = null; |
最后在Manifest文件中添加：
<application android:allowBackup="true" android:name=".AppModel" android:icon="@drawable/ic_launcher" android:label="@string/app_name" android:theme="@style/AppTheme" > |
这时再回到WkjTest工程，选中MainActivityTest类，右键选择Run As .... =>Android JUnit Test，这时Junit视图将显示测试用例通过。就这样，我们的第一个测试驱动开发周期就结束了。
相关文章：
[数据准备部分主要是
单元测试的测试数据准备策略方案。]
1 背景测试数据
测试背景数据是被测试系统运行依赖的业务数据，可能来自于其他外围系统，背景数据通常在被测试系统中作为输入数据，业务操作只是读取操作，并不做任何修改，业务处理完成后者部分可能保持位置不动也可能被备份到其他地方。
背景测试数据在测试前根据测试需求进行一次性准备，并在测试前对背景数据表进行备份作为数据基线。
背景测试数据修改时可能影响原有
测试用例和测试数据，因此背景数据要与测试数据和测试用例建立版本对应关系。
2 系统业务测试数据
系统业务数据包括静态业务数据和动态业务数据，静态业务数据指业务操作中不会被修改的数据例如业务字典、业务规则等，动态业务数据是指在业务操作过程中会被生成或修改的数据，例如审批记录、审批单据等等
系统业务数据与测试用例紧密相关，测试用例依赖于系统业务数据。测试执行前测试用例脚本依据测试输入数据修改业务数据满足测试需求，测试业务执行完，测试脚本要读取动态业务数据验证结果正确性，在测试执行结束前通常要对修改和影响的数据进行回退。
业务数据于测试集合建立对应关系。
3 测试输入数据
测试输入数据提供给测试脚本使用的测试数据，测试输入数据应该包括：业务触发数据、期望结果数据和配置数据等。
测试输入数据与测试用例是一一对应的关系，在单元测试和接口测试中采用读取Excel或者读取Database方式。
对特殊的输入对象数据或文件数据等，在指定目录中进行保存。通过接口方式读取这类数据。
测试输入数据与测试脚本建立对应关系。
1.背景介绍
性能测试平台是一款将性能测试执行、性能监控、数据分析和展示自动化起来的平台，尽可能的减少人工操作，提高效率。访问地址：http://qa.hz.netease.com/ptp
性能测试平台主要实现几个目标：
测试自动化，自动分发测试脚本、部署环境、执行测试、数据收集、数据集中分析，并生成结果报告。
资源集中管理，集中控制所有测试服务器和被测服务器，合理分配和调度资源，达到最大化利用。
持续集成，集成性能测试活动中的各个环节，对产品性能测试结果进行持续纵向和横向对比，关注产品性能变化趋势。
2.平台架构
主控机
负责安装测试工具、分发测试脚本和测试数据到各个负载机，部署性能测试环境。
负责安装监控工具到各个负载机和被测服务器。
启动负载机上的测试工具开始测试，启动负载机和被测服务器上的监控工具，进行全面资源监控。
全程检测测试是否正常，如果出错，抓取错误
日志进行报警。
检测测试是否结束，成功结束后收集业务性能数据和监控数据到主控机。
对业务性能数据进行处理、绘制图表，对监控数据进行处理绘制图表。
负载机
作为测试客户端启动负载测试工具模拟虚拟用户对被测服务进行并发测试。
监控测试执行日志和资源使用情况。
被测服务器
被测服务环境安装和部署。
监控被测服务日志和资源使用情况。
3.工具支持
STAF
Software Test Automation Framework是由IBM开发的开源、跨平台、支持多语言并且基于可重用的组件来构建的自动化测试框架。STAF 为测试人员提供了一个端到端的自动化测试解决方案。各个服务端点（称作STAF客户端）是对等的，从一个端点可直接调用另一端点（在另一台机器运行的程序）提供的服务。服务是一系列功能的集合。STAF 本身是一个后台程序 (STAFProc)，提供一种轻量级的分发机制，负责把请求转发给这些服务。
典型服务：
文件系统服务(FileSystem Service)：内部服务，利用此服务，STAF 可以对文件系统进行操作，比如复制，删除，查看等操作。
程序调用服务(Process Service)：内部服务，利用此服务，STAF 可以调用外部程序。
压缩服务(Zip Service)：外部服务，提供了压缩和解压的功能。
Ping服务(Ping Service)：内部服务，类似于操作系统的 ping 功能，用于检测远程的 STAF 是否运行。
Grinder
性能平台底层负载性能测试工具Grinder。是一个JavaTM负载测试框架，支持分布式测试，且是开源的。官方访问地址：http://grinder.sourceforge.net/
优点：
Jython脚本扩展性好，能模拟绝大多数复杂测试场景。
多样化的协议支持，HTTP、JDBC、JavaAPI等。
良好的性能表现，与Jmeter相比在某些场景下有优势。
Perfease
Perfease是从后台组blogbench中抽取的一款Linux服务器资源监控工具，监控全面、轻量级、性能损耗小。
内网下载地址：http://doc.hz.netease.com/pages/viewpage.action?pageId=16782036
主要监控工具和指标：
1. Vmstat：CPU使用率、上下文切换、中断次数、磁盘IO、内存使用情况等。
2. Iostat：kB_read/s、kB_wrtn/s、avgrq-sz、avgqu_sz、await、svctm、%util。
3. Top：Load average、Tasks、CPU、Mem、Swap、进程（VIRT、RES、%CPU、%MEM）。
4. Ksar: linux,mac and solaris。 官网：http://sourceforge.net/projects/ksar/ 。
在
Android应用开发中，相信很少有人在坚持先由设计人员做完整的概要设计 、详细设计，然后交给程序员进行编码实现了。通常是在有一个大体框架的情况下，就开始进行具体编码开发了。在这种情形下，开发速度可以有很大的提高，但是最终代码质量却不可避免的降低了。如何能既保持开发速度，同时又能保证开发质量呢？相信
测试驱动开发是一种比较可行的开发方法学。
测试驱动开发首先通过设计
测试用例，对从用户需求到方法接口进行细化，在构想这些测试用例的过程，就是站在使用者角度上来思考系统的过程，而传统方法中设计人员通常是站在技术人员的角度来思考问题，两者比较，显然测试驱动开发更有助于开发出更符合用户需求的产品，同时开发出高复用性代码。
测试驱动开发先写测试，这样就保证了充分考虑到了方法使用者需要，可以使方法更加合理。接下来进行代码开发，以尽可能短的时间通过测试用例，在这个过程中暂时忘掉OO和设计模式吧。当通过测试用例之后，我们再回过头来审视我们的代码实现，再去除类间依赖关系，使用恰当的设计模式，这比在开始阶段凭空想象要好得多。反复上述过程，自然可以得到质量更高的代码和系统。
然而，在Android系统下，进行测试驱动开发又增加了额外的难度，怎样对Activity、Provider、Service、Broadcaster等进行
单元测试，是一个必须要解决的问题，下面我们就以一个实际系统的开发，来看一看怎么解决这一系列的问题。
进行测试驱动开发，首先要做的就是建立一个真正可运行的骨架系统，做Android下的测试驱动开发也不例外。
先建立一个Android工程，这里以mhcs为例，采用Eclipse向导，建立该工程。假设这个工程在用户第一次使用时，需要显示三个介绍页面，用户在一张一张划过之后，才开始使用正常功能。接下来我们就以这个功能为例，详细描述一下在Android下怎样进行测试驱动开发。
首先，准备三张介绍图片，放入res/drawable目录下。我们定义FlipIntroActivity类来处理用户的划动操作及介绍图片显示。由于我们要在用户第一次运行时才向用户显示介绍页面，因些需要保存用户是否第一次使用系统的信息。我们利用Application的子类AppPreferences来管理应用所需的所有信息。
这时我们需要完成的功能就很清楚了，程序在第一次运行时显示介绍页面，而之后的运行中，不显示介绍页面。是否显示介绍页面，由AppPreferences类来管理。
下面在Eclipse里建立测试工程，选择新工程类型为Android Junit
Test工程，同时选择上面建立的工程作为被测试工程。
好了，最小可运行骨架系统已经建立好了，下面就可以进入正式的测试驱动开发流程了。
首先写测试用例：新建类AppPreferencesTest，由于被测试类AppPreferences是Application的子类，因此AppPreferencesTest类需要继承ApplicationTestCase
public class AppPreferencesTest extends ApplicationTestCase<AppPreferences> { public AppPreferencesTest(Class<AppPreferences> applicationClass) { super(applicationClass); } } |
我们首先测试AppPreferences在第一次运行时，可以返回true，在AppPreferencesTest类里添加如下测试代码：
public void testFirstRunTrue() { assertTrue(prefs.isFirstRun()); } private AppPreferences prefs = new AppPreferences(); |
这如你所看到的，这段代码编译器立即使出错误，不要担心，测试驱动开发总是从不能通过的测试用例开始的，每次努力通过一个测试用例，在通过一个个测试用例的过程中取得进展。
下面我们首先编写代码，通过这个测试用例，我们在AppPreferences类中添加如下代码：
public boolean isFirstRun() { return isFirstRun; } public void setFirstRun(boolean isFirstRun) { this.isFirstRun = isFirstRun; } private boolean isFirstRun = true; |
但是，如果是第二次运行，系统不是还会显示true吗？这明显是不正确的！一点儿没错，这段代码确实没有实现我们之前的想法，但是这段代码却可以通过我们的测试用例，测试驱动开发的原则就是以尽量快的速度通过测试用例。
好了，在测试工程中选择AppPreferencesTest，然后选择Android Junit Test，系统运行，你会在Junit视图中看到绿色用例通过标记。
下面添加一段代码，测试当第二次运行时的情况：
public void testSecondAndMoreRun() { prefs.isFirstRun(); assertFalse(prefs.isFirstRun()); } |
运行上述工程，结果测试用例testSecondAndMoreRun不能通过，下面我们就来处理这种情况，在生产工程中的AppPreferences类中添加如下代码：
public boolean isFirstRun() { boolean orgVal = isFirstRun; isFirstRun = false; return orgVal; } |
这时再来运行测试工程的AppPreferencesTest类，又可以看到令我们心旷神怡的绿色通过标志了。
下面就剩下第一次运行可以通过，第二次运行不能通过。具体代码如下所示：
在生产项目的类AppPreferences中添加：
@Override public void onCreate() { super.onCreate(); } public void onTerminate() { super.onTerminate(); } public boolean isFirstRun() { prefs = getSharedPreferences("mhcs", MODE_PRIVATE); boolean orgVal = isFirstRun; isFirstRun = false; Editor editor = prefs.edit(); editor.putBoolean(PREF_IS_FIRST_RUN, false); editor.commit(); return orgVal; } public void setFirstRun(boolean isFirstRun) { this.isFirstRun = isFirstRun; } public final static String PREF_IS_FIRST_RUN = "isFirstRun"; private SharedPreferences prefs = null; private boolean isFirstRun = true; |
在测试项目的测试类中添加代码：
public void testFirstRunTrue() { createApplication(); prefs = getApplication(); Editor editor = mContext.getSharedPreferences("mhcs", 0).edit(); editor.clear().commit(); assertTrue(prefs.isFirstRun()); } public void testSecondAndMoreRun() { createApplication(); prefs = getApplication(); assertFalse(prefs.isFirstRun()); } |
尤其需要注意的是testFirstRunTrue方法中，先将SharedPreferences清空的处理，这样可以模拟程序安装后第一次运行。
运行测试项目的测试用例，终于可以看到完整功能的绿色通过标志了。
这个工具用了几次，发现非常好用，及时记录
测试过程中的问题，不打断测试思路。
感兴趣的同学可以访问我的博客：http://jabcf.blog.163.com/blog/static/348312402013421113716508/
下载地址：http://testing.gershon.info/reporter/
特别感谢：邰晓梅老师 在一次ET的在线培训课程，邰晓梅老师使用的是这个工具。
Rapid Reproter，是一款轻量级的辅助记录工具，主要使用在SBTM(Session Based Testing Management)。
可以保证尽量不中断测试思路，使得测试过程更加完整，事后整理也比较方便。
可以按时间顺序保存测试过程中的任务记录和截屏信息，保存为csv文件，可导出为html。
下载
下载下来只有一个可执行的exe文件，适用于
Windows平台，并且需要.NET 3.5版本，大多数机器都可以的。
运行
双击运行，会出现一个悬浮窗体，总在最前，可以拖动，可以调节透明度。
在mysql中创建一个Schema和创建一个Database的效果好像是一样的，但是在sqlserver和orcal数据库中效果又是不同的，目前我只能理解为在mysql中schema<==>database;
假如我们想了解数据库中的user和schema的关系，首先必须要清楚数据库中的user和schema的概念。
在sqlserver2000中，由于架构的原因，user和schema总有一层隐含的关系，让我们很少意识到其实user和schema是两种完全不同的概念，不过在sqlserver2005中这种架构被打破了，user和schema也被分开了。
首先来做一个比喻，什么是database，schema，table，列，行，user？可以把database看作是一个大的仓库，仓库分了很多很多的房间，schema就是其中的房间，一个schema代表一个房间，table可以看作是每个schema中的床，table（床）就被放入每个房间中，不能放置在房间之外，那岂不是晚上睡觉无家可归啊。然后床上可以放置很多物品，好比table可以放置很多列和行一样，数据库中存储数据的基本单元是table，现实中每个仓库放置物品的基本单位就是床，user就是每个schema的主人，（所以schema包含的object，而不是user），其实user是对应与数据库的（即user是每个对应数据库的主人），既然有操作数据库的（仓库）的权利，就肯定有操作数据库中每个schema（房间）的权利，就是说每个数据库映射的user有每个schema（房间）的钥匙，换句话说，如果它是某个仓库的主人，那么这个仓库的使用权和仓库中的所有东西都是他的（包括房间），他有完全的操作权，可以扔掉不用的东西从每个房间，也可以放置一些有用的东西到某一个房间，这个现实中的相似，我还可以给user分配具体的权限，也就是他到某一房间能做些什么，是只能看（read-only），还是可以像主人一样有所有的控制权（r/w），这个就要看这个user所对应的角色role了。
在sqlserver2000中，假如我们在某一数据库中创建了用户Bosco，那么此时后台也为我们默认的创建了schema【Bosco】，schema的名字和user的名字相同，这也是我们分不清用户和schema的原因。
在sqlserver2005中，为了向后兼容，当你用sp_adduser存储过程创建一个用户的时候，sqlserver2005同时也创建了一个和用户名相同的schema，然而这个存储过程是为了向后兼容才保留的，我们应该逐渐熟悉用新的DDL语言create user和create schema来操作数据库，在sqlserver2005中，当我们用create user创建数据库用户时，我们可以用该用户指定一个已经存在的schema作为默认的schema，如果我们不指定，则该用户所默认的schema即为dbo schema，dbo房间（schema）好比一个大的公共房间，在当前登录用户没有默认schema的前提下，如果你在大仓库中进行一些操作，比如create table，如果没有制定特定的房间（schema），那么你的物品就只好放进公共的dbo房间（schema）了。但是如果当前登录用户有默认的schema，那么所做的一切操作都是在默认的schema上进行（比如当前登录用户为login1，该用户的默认schema为login1，那么所做的所以操作都是在这个login1默认schema上进行的。实验已经证明的确如此）。估计此时你会有一点晕，刚才说dbo是一个schema，但是你可以在数据库中查看到，dbo同事也是一个user，晕了吧。
在sqlserver2005中创建一个数据库的时候，会有一些schema包括进去，被包括进去的schema有：dbo，INFORMATION_SCHEMA,guest,sys等等（还有一些角色schema）。
在上文中已经提到了，在sqlserver2005中当用存储过程sp_adduser创建一个user时，同时sqlserver2005也为我们创建了一个默认的和用户名相同的schema，这个问题出来了，当我们create table a时，如果没有特定的schema做前缀，这个a表创建在了哪个schema上，即进入了哪个房间？答案是：
1.如果当前操作数据库的用户（可以用select current_user查出来）有默认的schema（在创建用的时候指定了），那么表a被创建在了默认的schema上。
2.如果当前操作数据库的用户没有默认的schema（即在创建user的时候默认为空），但是有一个和用户名同名的schema，那么表a照样被创建在了dbo schema上，即使有一个和用户名同名的schema存在，由于它不是该用户默认的schema，所以创建表的时候是不会考虑的，当作一般的schema来处理，别看名字相同，可是没有任何关系哦。
3.如果在创建表a时候指定了特定的schema做前缀，则表a被创建在了指定的schema上（有权限吗？）
现在问题又出来了，在当前操作数据库的用户（用select current_user可以查看到，再次强调)没有默认schema的前提下，当我们用create table a语句时，a表会去寻找dbo schema，并试图创建在dbo schema上，但是如果创建a表的用户只有对dbo schema的只读权限，而没有写的权限呢？这个时候a表既不是建立不成功，这个就是会提到的login，user，role和schema四者的关系，在这里，为了避免混淆和提高操作数据库的速度（在少量数据范围内，对我们肉眼来说几乎看不到差异），我们最好每次在操作数据库对象的时候都显式地指定特定的Schema最为前缀。
现在如果登录的用户为Sue，该用户有一个默认Schema也为Sue，那么如果现在有一条查询语句为Select * from mytable, 那么搜寻每个房间（Schema）的顺序是怎样的呢？顺序如下：
1. 首先搜寻sys.mytable （Sys Schema）
2. 然后搜寻Sue.mytable (Default Schema)
3. 最后搜寻 dbo.mytable (Dbo Schema)
执行的顺序大家既然清楚了，那么以后在查询数据库表中的数据时，最好指定特定的Schema前缀，这样子，数据库就不用去扫描Sys Schema了，当然可以提高查询的速度了。
另外需要提示一下的是，每个数据库在创建后，有4个Schema是必须的（删都删不掉），这4个Schema为：dbo，guest，sys和INFORMATION_SCHEMA，其余的Schema都可以删除。
1.php程序
<?php mysql_connect("localhost","root",""); mysql_select_db("myhospitalv2"); $q=mysql_query("SELECT * FROM user2 "); while($e=mysql_fetch_object($q)) $output[]=$e; print(json_encode($output)); mysql_close(); ?> |
2.浏览器返回结果
| [{"id":"1","name":"Tony","sex":"1","birthyear":"1999"},{"id":"2","name":"Jim","sex":"1","birthyear":"1987"},{"id":"3","name":"Lucy","sex":"0","birthyear":"1988"},{"id":"4","name":"Tom","sex":"1","birthyear":"1980"}] |
3.总结
使用php引擎操作
MySQL数据库，若返回结果为记录集，将记录集中记录进行重新存储，如上
$q=mysql_query("SELECT * FROM user2 "); while($e=mysql_fetch_object($q)) $output[]=$e; |
然后调用json_encode（）进行JSON数据封装，可得到正确的JSON数据格式，用于不同设备间的数据传输。
首先举一个简单的例子，如果你想实现一个接口，但是这个接口中的一个方法和你构想的这个类中的一个方法的名称，参数相同，你应该怎么办？这时候，你可以建一个内部类实现这个接口。由于内部类对外部类的所有内容都是可访问的，所以这样做可以完成所有你直接实现这个接口的功能。
不过你可能要质疑，更改一下方法的不就行了吗？
的确，以此作为设计内部类的理由，实在没有说服力。
真正的原因是这样的，java 中的内部类和接口加在一起，可以的解决常被 C++ 程序员抱怨 java 中存在的一个问题??没有多继承。实际上，C++ 的多继承设计起来很复杂，而 java 通过内部类加上接口，可以很好的实现多继承的效果。
内部类：一个内部类的定义是定义在另一个内部的类。
原因是：
1.一个内部类的对象能够访问创建它的对象的实现，包括私有数据。
2.对于同一个包中的其他类来说，内部类能够隐藏起来。
3.匿名内部类可以很方便的定义回调。
4.使用内部类可以非常方便的编写事件驱动程序。
1.内部类
提起 Java 内部类（Inner Class）可能很多人不太熟悉，实际上类似的概念在 C++ 里也有，那就是嵌套类（Nested Class），关于这两者的区别与联系，在下文中会有对比。内部类从表面上看，就是在类中又定义了一个类（下文会看到，内部类可以在很多地方定义），而实际上并没有那么简单，乍看上去内部类似乎有些多余，它的用处对于初学者来说可能并不是那么显著，但是随着对它的深入了解，你会发现Java的设计者在内部类身上的确是用心良苦。学会使用内部类，是掌握Java高级编程的一部分，它可以让你更优雅地设计你的程序结构。下面从以下几个方面来介绍：
* 第一次见面
public interface Contents { int value(); } public interface Destination { String readLabel(); } public class Goods { private class Content implements Contents { private int i = 11; public int value() { return i; } } protected class GDestination implements Destination { private String label; private GDestination(String whereTo) { label = whereTo; } public String readLabel() { return label; } } public Destination dest(String s) { return new GDestination(s); } public Contents cont() { return new Content(); } } class TestGoods { public static void main(String[] args) { Goods p = new Goods(); Contents c = p.cont(); Destination d = p.dest("Beijing"); } } |
在这个例子里类 Content 和 GDestination 被定义在了类 Goods 内部，并且分别有着 protected 和 private 修饰符来控制访问级别。Content 代表着 Goods 的内容，而 GDestination 代表着 Goods 的目的地。它们分别实现了两个接口 Content 和 Destination。在后面的 main 方法里，直接用 Contents c 和 Destination d 进行操作，你甚至连这两个内部类的名字都没有看见！这样，内部类的第一个好处就体现出来了??隐藏你不想让别人知道的操作，也即封装性。
同时，我们也发现了在外部类作用范围之外得到内部类对象的第一个方法，那就是利用其外部类的方法创建并返回。上例中的 cont() 和 dest() 方法就是这么做的。那么还有没有别的方法呢？当然有，其语法格式如下：
outerObject=new outerClass(Constructor Parameters);
outerClass.innerClass innerObject=outerObject.new InnerClass(Constructor Parameters);
注意在创建非静态内部类对象时，一定要先创建起相应的外部类对象。至于原因，也就引出了我们下一个话题??
* 非静态内部类对象有着指向其外部类对象的引用
对刚才的例子稍作修改：
public class Goods { private valueRate=2; private class Content implements Contents { private int i = 11 * valueRate; public int value() { return i; } } protected class GDestination implements Destination { private String label; private GDestination(String whereTo) { label = whereTo; } public String readLabel() { return label; } } public Destination dest(String s) { return new GDestination(s); } public Contents cont() { return new Content(); } } |
修改的部分用蓝色显示了。在这里我们给 Goods 类增加了一个 private 成员变量 valueRate，意义是货物的价值系数，在内部类 Content 的方法 value() 计算价值时把它乘上。我们发现，value() 可以访问 valueRate，这也是内部类的第二个好处??一个内部类对象可以访问创建它的外部类对象的内容，甚至包括私有变量！这是一个非常有用的特性，为我们在设计时提供了更多的思路和捷径。要想实现这个功能，内部类对象就必须有指向外部类对象的引用。Java 编译器在创建内部类对象时，隐式的把其外部类对象的引用也传了进去并一直保存着。这样就使得内部类对象始终可以访问其外部类对象，同时这也是为什么在外部类作用范围之外向要创建内部类对象必须先创建其外部类对象的原因。
有人会问，如果内部类里的一个成员变量与外部类的一个成员变量同名，也即外部类的同名成员变量被屏蔽了，怎么办？没事，Java里用如下格式表达外部类的引用：
outerClass.this
有了它，我们就不怕这种屏蔽的情况了。
* 静态内部类
和普通的类一样，内部类也可以有静态的。不过和非静态内部类相比，区别就在于静态内部类没有了指向外部的引用。这实际上和 C++ 中的嵌套类很相像了，Java 内部类与 C++ 嵌套类最大的不同就在于是否有指向外部的引用这一点上，当然从设计的角度以及以它一些细节来讲还有区别。
除此之外，在任何非静态内部类中，都不能有静态数据，静态方法或者又一个静态内部类（内部类的嵌套可以不止一层）。不过静态内部类中却可以拥有这一切。这也算是两者的第二个区别吧。
* 局部内部类
是的，Java 内部类也可以是局部的，它可以定义在一个方法甚至一个代码块之内。
public class Goods1 { public Destination dest(String s) { class GDestination implements Destination { private String label; private GDestination(String whereTo) { label = whereTo; } public String readLabel() { return label; } } return new GDestination(s); } public static void main(String[] args) { Goods1 g= new Goods1(); Destination d = g.dest("Beijing"); } } |
上面就是这样一个例子。在方法dest中我们定义了一个内部类，最后由这个方法返回这个内部类的对象。如果我们在用一个内部类的时候仅需要创建它的一个对象并创给外部，就可以这样做。当然，定义在方法中的内部类可以使设计多样化，用途绝不仅仅在这一点。
下面有一个更怪的例子：
public class Goods2{ private void internalTracking(boolean b) { if(b) { class TrackingSlip { private String id; TrackingSlip(String s) { id = s; } String getSlip() { return id; } } TrackingSlip ts = new TrackingSlip("slip"); String s = ts.getSlip(); } } public void track() { internalTracking(true); } public static void main(String[] args) { Goods2 g= new Goods2(); g.track(); } } |
你不能在 if 之外创建这个内部类的对象，因为这已经超出了它的作用域。不过在编译的时候，内部类 TrackingSlip 和其他类一样同时被编译，只不过它由它自己的作用域，超出了这个范围就无效，除此之外它和其他内部类并没有区别。
2.匿名类
匿名类是不能有名称的类，所以没办法引用他们。必须在创建时，作为new语句的一部分来声明他们。
这就要采用另一种形式的new语句，如下所示：
new <类或接口> <类的主体>
这种形式的new语句声明一个新的匿名类，他对一个给定的类进行扩展，或实现一个给定的接口。他还创建那个类的一个新实例，并把他作为语句的结果而返回。要扩展的类和要实现的接口是new语句的操作数，后跟匿名类的主体。
假如匿名类对另一个类进行扩展，他的主体能够访问类的成员、覆盖他的方法等等，这和其他任何标准的类都是相同的。假如匿名类实现了一个接口，他的主体必须实现接口的方法。
注意匿名类的声明是在编译时进行的，实例化在运行时进行。这意味着for循环中的一个new语句会创建相同匿名类的几个实例，而不是创建几个不同匿名类的一个实例。
从技术上说，匿名类可被视为非静态的内部类，所以他们具备和方法内部声明的非静态内部类相同的权限和限制。
假如要执行的任务需要一个对象，但却不值得创建全新的对象（原因可能是所需的类过于简单，或是由于他只在一个方法内部使用），匿名类就显得很有用。匿名类尤其适合在Swing应用程式中快速创建事件处理程式。
interface pr { void print1(); } public class noNameClass { public pr dest() { return new pr() { public void print1() { System.out.println("Hello world!!"); } }; } } public static void main(String args[]) { noNameClass c = new noNameClass(); pr hw = c.dest(); hw.print1(); } |
pr 也可以是一个类，但是你外部调用的方法必须在你的这个类或接口中声明，外部不能调用匿名类内部的方法。
Java 中内部匿名类用的最多的地方也许就是在 Frame 中加入 Listner 了吧。
import java.awt.*; import java.awt.event.*; public class QFrame extends Frame { public QFrame() { this.setTitle(\"my application\"); addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { dispose(); System.exit(0); } }); this.setBounds(10,10,200,200); } } |
内部匿名类，就是建立一个内部的类，但没有给你命名，也就是没有引用实例的变量。
new WindowAdapter() { public void windowClosing(WindowEvent e) { dispose(); System.exit(0); } } |
new 是建立一个 WindowAdapter 对象，后面一个 {} 表示这个括号中的操作作用于这个默认的对名象，而上面的 Java 程序中后面是一个函数体。
这个用法的作用是：创建一个对象的实例，并且 override 它的一个函数。
打开 WindowAdapter 的代码可以发现。它是一个抽象类。它是对 WindowListener 接口的一个实现。
Frame.addWindowListner(); 的参数是一个 WindowListner ，而实现上是传一个从WindowAdapter 派生出的一个匿名类。
有一点需要注意的是，匿名内部类由于没有名字，所以它没有构造函数（但是如果这个匿名内部类继承了一个只含有带参数构造函数的父类，创建它的时候必须带上这些参数，并在实现的过程中使用 super 关键字调用相应的内容）。如果你想要初始化它的成员变量，有下面几种方法：
1. 如果是在一个方法的匿名内部类，可以利用这个方法传进你想要的参数，不过记住，这些参数必须被声明为 final 。
2. 将匿名内部类改造成有名字的局部内部类，这样它就可以拥有构造函数了。
3. 在这个匿名内部类中使用初始化代码块。
LoadRunner参数化设置中有九种取值方式：（以用户名参数user为例，其数据参数列表为：jojo、201401、201402、201403、201405、201406、201407、201408、201409，迭代次数设置为10次）
1、Sequential+Each Iteration
脚本会执行10次，每次迭代会按数据列表顺序取值，每一次迭代中出现的参数user的值是当前第一次参数替换的值。第1次迭代均为jojo，以此类推。
2、Sequential+Each Occurrence
脚本执行10次，每次迭代中出现参数user，顺序取值一次，第1次迭代中出现3次user,则user取值为jojo、201401、201402，等到取值到201409，下次会从第一个数顺序取值。
3、Sequential+Once
脚本执行10次，user只取值一次，每次出现的user替换参数值都是jojo。
4、Random+Each Iteration
脚本执行10次，数据表中的数据随机取，比如第一次迭代取值201405，则这次迭代中出现参数user地方则用201405替代。
5、Random+Each Occurrence
脚本执行10次，数据表中的数据随机取，迭代过程中只要出现参数user的地方就随机取值一次。第1次迭代出现3次user，则随机数为201407、jojo、201403。
6、Random+Once
脚本执行10，数据表中数据随机取值，参数user只取值一次，10次迭代过程中出现参数user的地方都是用随机取值（比如201406）替代。
7、Unique+Each Iteration
每个用户对应一次数据，当迭代次数超过用户数据量，根据设置情况处理情况，如下图所示：
每次迭代出现的参数user用当前取值替代。
8、Unique+Each Iteration
当前有9条数据，没出现一次参数user，只能用一个数值替代，9条数据取完之后根据设置超出值处理。每次迭代出现3次user，则第4次迭代无数据可取，根据超出时设置处理后面的情况。此方式只能执行者决定每个user值分配块的大小。如下图所示：
9、Unique+Once
参数user只取值一次，所有的出现参数user都用jojo替换，当前脚本可执行10次。设置如图所示：
首先，当然是找到能够解析PDF的完美组件，
百度和
谷歌不约而同的告诉我们。IText是王道。而目前开源的组件中，Itext的确是一个First Choice，如果各位单纯是做把图片转成PDF或者自己写了Velocity或者FreeMarker模板生成了HTML是非常推荐直接用Itext来进行的。而如果，大家像我这样已经有前人写好了HTML页面或者懒得写FreeMarker模板的话。可以直接看下一段。
由于他们已经写好了HTML页面，而且显示已经很完美了。那我要做的就是能完美解析HTML+CSS的PDF生成工具。这时候flying-saucer进入了我的选择范围中。
http://code.google.com/p/flying-saucer/
上面是网址，这个工具托管在GoogleCode上面，作者做他们能够做下面的
工作：
Flying Saucer takes XML or XHTML and applies CSS 2.1-compliant stylesheets to it, in order to render to PDF (via iText), images, and on-screen using Swing or SWT。
不难看出工作原理，就是解析XML或者XHTML并且包括css样式表，并且用Swing或者SWT的组件生成PDF的功能。这解决了页面的显示问题。IText自身的一个很严重的问题就是解析CSS有很大的问题。而这个解决了。下面就是用Flying Saucer来实现的代码：
public boolean convertHtmlToPdf(String inputFile, String outputFile) throws Exception { OutputStream os = new FileOutputStream(outputFile); ITextRenderer renderer = new ITextRenderer(); String url = new File(inputFile).toURI().toURL().toString(); renderer.setDocument(url); // 解决中文支持问题 ITextFontResolver fontResolver = renderer.getFontResolver(); fontResolver.addFont("C:/Windows/Fonts/SIMSUN.TTC", BaseFont.IDENTITY_H, BaseFont.NOT_EMBEDDED); //解决图片的相对路径问题 renderer.getSharedContext().setBaseURL("file:/D:/"); renderer.layout(); renderer.createPDF(os); os.flush(); os.close(); return true; } |
上面这段代码是这样的，输入一个HTML地址URL = inputFile，输入一个要输出的地址，就可以在输出的PDF地址中生成这个PDF。
注意事项：
1.输入的HTML页面必须是标准的XHTML页面。页面的顶上必须是这样的格式：
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
并且HTML页面的语法必须是非常严谨的，所有标签都必须闭合等等（由于flying-Saucer做了XML解析的工作，不严谨会报错的。），这是对页面的第一个要求。
2.要用到图片的地方写相对路径的形式，比如：
<img src="a.jpg" alt="323" width="252" height="80" />
而它的图片位置则必须在Java代码中指定。
renderer.getSharedContext().setBaseURL("file:/D:/");
也有另一种方法就是直接在<img>标签中写绝对路径。
3.Flying-Saucer在解析tiff格式的图片的时候会报错。具体原因我还没找到。希望大家能够指点我。
4.如果在页面中有中文字体的话。必须在HTML代码中的样式中写上某种字体的css，并且必须是用英文的，然后在Java代码中写上对应的文件位置。
ITextFontResolver fontResolver = renderer.getFontResolver();
fontResolver.addFont("C:/Windows/Fonts/SIMSUN.TTC", BaseFont.IDENTITY_H, BaseFont.NOT_EMBEDDED);
上面的方法是添加了宋体。也可以添加其他字体。
以上就是解决方案。