❶ 怎么用mockito mock 单例
当被问到要实现一个单例模式时，很多人的第一反应是写出如下的代码，包括教科书上也是这样教我们的。一二三四5陆漆吧9一0一一publicclassSingleton{;privateSingleton(){}(){if(instance==null){instance=newSingleton();}returninstance;}}这段代码简单明了，而且使用了懒加载模式，但是却存在致命的问题。当有多个线程并行调用getInstance()的时候，就会创建多个实例。也就是说在多线程下不能正常工作。懒汉式，线程安全为了解决上面的问题，最简单的方法是将整个getInstance()方法设为同步（synchronized）。一二三四5陆(){if(instance==null){instance=newSingleton();}returninstance;}虽然做到了线程安全，并且解决了多实例的问题，但是它并不高效。因为在任何时候只能有一个线程调用getInstance()方法。但是同步操作只需要在第一次调用时才被需要，即第一次创建单例实例对象时。这就引出了双重检验锁。双重检验锁双重检验锁模式（doublecheckedlockingpattern），是一种使用同步块加锁的方法。程序员称其为双重检查锁，因为会有两次检查instance==null，一次是在同步块外，一次是在同步块内。为什么在同步块内还要再检验一次？因为可能会有多个线程一起进入同步块外的if，如果在同步块内不进行二次检验的话就会生成多个实例了。一二三四5陆漆吧9一(){if(instance==null){//SingleCheckedsynchronized(Singleton.class){if(instance==null){//DoubleCheckedinstance=newSingleton();}}}returninstance;}这段代码看起来很完美，很可惜，它是有问题。主要在于instance=newSingleton()这句，这并非是一个原子操作，事实上在JVM中这句话大概做了下面三件事情。给instance分配内存调用Singleton的构造函数来初始化成员变量将instance对象指向分配的内存空间（执行完这步instance就为非null了）但是在JVM的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是一-二-三也可能是一-三-二。如果是后者，则在三执行完毕、二未执行之前，被线程二抢占了，这时instance已经是非null了（但却没有初始化），所以线程二会直接返回instance，然后使用，然后顺理成章地报错。我们只需要将instance变量声明成volatile就可以了。一二三四5陆漆吧9一0一一一二一三一四一5一陆publicclassSingleton{;//声明成volatileprivateSingleton(){}(){if(instance==null){synchronized(Singleton.class){if(instance==null){instance=newSingleton();}}}returninstance;}}有些人认为使用volatile的原因是可见性，也就是可以保证线程在本地不会存有instance的副本，每次都是去主内存中读取。但其实是不对的。使用volatile的主要原因是其另一个特性：禁止指令重排序优化。也就是说，在volatile变量的赋值操作后面会有一个内存屏障（生成的汇编代码上），读操作不会被重排序到内存屏障之前。比如上面的例子，取操作必须在执行完一-二-三之后或者一-三-二之后，不存在执行到一-三然后取到值的情况。从“先行发生原则”的角度理解的话，就是对于一个volatile变量的写操作都先行发生于后面对这个变量的读操作（这里的“后面”是时间上的先后顺序）。但是特别注意在Java5以前的版本使用了volatile的双检锁还是有问题的。其原因是Java5以前的JMM（Java内存模型）是存在缺陷的，即时将变量声明成volatile也不能完全避免重排序，主要是volatile变量前后的代码仍然存在重排序问题。这个volatile屏蔽重排序的问题在Java5中才得以修复，所以在这之后才可以放心使用volatile。相信你不会喜欢这种复杂又隐含问题的方式，当然我们有更好的实现线程安全的单例模式的法。饿汉式staticfinalfield这种方法非常简单，因为单例的实例被声明成static和final变量了，在第一次加载类到内存中时就会初始化，所以创建实例本身是线程安全的。一二三四5陆漆吧9一0publicclassSingleton{//类加载时就初始化=newSingleton();privateSingleton(){}(){returninstance;}}这种写法如果完美的话，就没必要在啰嗦那么多双检锁的问题了。缺点是它不是一种懒加载模式（lazyinitialization），单例会在加载类后一开始就被初始化，即使客户端没有调用getInstance()方法。饿汉式的创建方式在一些场景中将无法使用：譬如Singleton实例的创建是依赖参数或者配置文件的，在getInstance()之前必须调用某个方法设置参数给它，那样这种单例写法就无法使用了。静态内部类staticnestedclass我比较倾向于使用静态内部类的方法，这种方法也是《EffectiveJava》上所推荐的。一二三四5陆漆吧9publicclassSingleton{{=newSingleton();}privateSingleton(){}(){returnSingletonHolder.INSTANCE;}}这种写法仍然使用JVM本身机制保证了线程安全问题；由于SingletonHolder是私有的，除了getInstance()之外没有法访问它，因此它是懒汉式的；同时读取实例的时候不会进行同步，没有性能缺陷；也不依赖JDK版本。枚举Enum用枚举写单例实在太简单了！这也是它最大的优点。下面这段代码就是声明枚举实例的通常做法。一二三publicenumEasySingleton{INSTANCE;}我们可以通过EasySingleton.INSTANCE来访问实例，这比调用getInstance()方法简单多了。创建枚举默认就是线程安全的，所以不需要担心doublecheckedlocking，而且还能防止反序列化导致重新创建新的对象。但是还是很少看到有人这样写，可能是因为不太熟悉吧。总结一般来说，单例模式有五种写法：懒汉、饿汉、双重检验锁、静态内部类、枚举。上述所说都是线程安全的实现，文章开头给出的第一种方法不算正确的写
❷ C# 单元测试 MOQ 怎么MOCK
你想测试C类的方法那就直接在C类方法名上右键单元测试就行了啊
❸ mock怎么使用道具
1.mock的页面的左下角上会一排的图形，然后右击一下那个椭圆形的图形，就好出现一小排的几个图形，然后用鼠标点上去查看一下是什么文字，查看完毕之后，单击一下道具就完成了。
2.Mock说白了就是打桩（Stub）或则模拟，当你调用一个不好在测试中创建的对象时，Mock框架为你模拟一个和真实对象类似的替身来完成相应的行为。
3.mock主要的作用就是解决依赖问题，达到解耦作用当我们测试某个目标接口（模块）时，该接口依赖其他接口，当被依赖的接口未开发完成时，可以用mock模拟被依赖接口，完成目标接口的测试。
4.mock的优点是成本低，使用简单，只需要学习 Mock.js 模板语法。不受网络影响。改动 Mock 能够快速看到效果。
5.mock的缺点就是Mock 代码与业务代码耦合高，上线容易遗漏测试代码，为代码偷偷埋下一颗地雷。无法快速响应文档改动，保持Mock 返回数据与文档一致。只有前端开发人员能用到 Mock，无法与其他部门人员协同工作。没有 API 请求，不够真实。
❹ mock测试方法，后面的方法依赖于前面的结果怎么测
mock测试方法用于构造对象，而不是你说的方法
比如，你现在要调用数据库，但这块也许还没完成，无法用orm框架进行映射，你就可以先new一些这样的对象，将它们保存或当作参数传入等
比如某接口中(UserDao)你有一个方法叫：queryUser(String name)，但你的真正实现未完成，你就可以先写一个Mock类，MockUserDaoImpl
queryUser(String name){
User user = new User();
user.setName...
user.setPassword...
}
你说的两种方法，不需要mock，直接调用方法，传入参数，然后利用断言
assert*
❺ 如何用python 来mock一个web响应
什么是mock?
mock在翻译过来有模拟的意思。这里要介绍的mock是辅助单元测试的一个模块。它允许您用模拟对象替换您的系统的部分，并对它们已使用的方式进行断言。
在Python2.x 中 mock是一个单独模块，需要单独安装。
> pip install -U mock
在Python3.x中，mock已经被集成到了unittest单元测试框架中，所以，可以直接使用。
可能你和我初次接触这个概念的时候会有这样的疑问：把要测的东西都模拟掉了还测试什么呢？
但在，实际生产中的项目是非常复杂的，对其进行单元测试的时候，会遇到以下问题：
接口的依赖
外部接口调用
测试环境非常复杂
单元测试应该只针对当前单元进行测试, 所有的内部或外部的依赖应该是稳定的, 已经在别处进行测试过的.使用mock 就可以对外部依赖组件实现进行模拟并且替换掉, 从而使得单元测试将焦点只放在当前的单元功能。
简单的例子
我们先从最简单例子开始。
molar.py
#molar.py
class Count():
def add(self):
pass
这里要实现一个Count计算类，add() 方法要实现两数相加。但，这个功能我还没有完成。这时就可以借助mock对其进行测试。
mock_demo01.py
from unittest import mock
import unittest
from molar import Count
# test Count class
class TestCount(unittest.TestCase):
def test_add(self):
count = Count()
count.add = mock.Mock(return_value=13)
result = count.add(8,5)
self.assertEqual(result,13)
if __name__ == '__main__':
unittest.main()
count = Count()
首先，调用被测试类Count() 。
count.add = mock.Mock(return_value=7)
通过Mock类模拟被调用的方法add()方法，return_value 定义add()方法的返回值。
result = count.add(2,5)
接下来，相当于在正常的调用add()方法，传两个参数2和5，然后会得到相加的结果7。然后，7的结果是我们在上一步就预先设定好的。
self.assertEqual(result,7)
最后，通过assertEqual()方法断言，返回的结果是否是预期的结果7。
运行测试结果：
> python3 mock_demo01.py
.
----------------------------------------------------------------------
Ran 1 test in 0.000s
OK
这样一个用例就在mock的帮助下编写完成，并且测试通过了。
完成功能测试
再接下来完成mole.py文件中add()方法。
#mole.py
class Count():
def add(self, a, b):
return a + b
然后，修改测试用例：
from unittest import mock
import unittest
from mole import Count
class MockDemo(unittest.TestCase):
def test_add(self):
count = Count()
count.add = mock.Mock(return_value=13, side_effect=count.add)
result = count.add(8, 8)
print(result)
count.add.assert_called_with(8, 8)
self.assertEqual(result, 16)
if __name__ == '__main__':
unittest.main()
count.add = mock.Mock(return_value=13, side_effect=count.add)
side_effect参数和return_value是相反的。它给mock分配了可替换的结果，覆盖了return_value。简单的说，一个模拟工厂调用将返回side_effect值，而不是return_value。
所以，设置side_effect参数为Count类add()方法，那么return_value的作用失效。
result = count.add(8, 8)
print(result)
这次将会真正的调用add()方法，得到的返回值为16（8+8）。通过print打印结果。
assert_called_with(8,8)
检查mock方法是否获得了正确的参数。
解决测试依赖
前面的例子，只为了让大家对mock有个初步的印象。再接来，我们看看如何mock方法的依赖。
例如，我们要测试A模块，然后A模块依赖于B模块的调用。但是，由于B模块的改变，导致了A模块返回结果的改变，从而使A模块的测试用例失败。其实，对于A模块，以及A模块的用例来说，并没有变化，不应该失败才对。
这个时候就是mock发挥作用的时候了。通过mock模拟掉影响A模块的部分（B模块）。至于mock掉的部分（B模块）应该由其它用例来测试。
# function.py
def add_and_multiply(x, y):
addition = x + y
multiple = multiply(x, y)
return (addition, multiple)
def multiply(x, y):
return x * y
然后，针对 add_and_multiply()函数编写测试用例。func_test.py
import unittest
import function
class MyTestCase(unittest.TestCase):
def test_add_and_multiply(self):
x = 3
y = 5
addition, multiple = function.add_and_multiply(x, y)
self.assertEqual(8, addition)
self.assertEqual(15, multiple)
if __name__ == "__main__":
unittest.main()
运行结果：
> python3 func_test.py
.
----------------------------------------------------------------------
Ran 1 test in 0.000s
OK
目前运行一切正确常，然而，add_and_multiply()函数依赖了multiply()函数的返回值。如果这个时候修改multiply()函数的代码。
……
def multiply(x, y):
return x * y + 3
这个时候，multiply()函数返回的结果变成了x*y加3。
再次运行测试：
> python3 func_test.py
F
======================================================================
FAIL: test_add_and_multiply (__main__.MyTestCase)
----------------------------------------------------------------------
Traceback (most recent call last):
File "fun_test.py", line 19, in test_add_and_multiply
self.assertEqual(15, multiple)
AssertionError: 15 != 18
----------------------------------------------------------------------
Ran 1 test in 0.000s
FAILED (failures=1)
测试用例运行失败了，然而，add_and_multiply()函数以及它的测试用例并没有做任何修改，罪魁祸首是multiply()函数引起的，我们应该把 multiply()函数mock掉。
import unittest
from unittest.mock import patch
import function
class MyTestCase(unittest.TestCase):
@patch("function.multiply")
def test_add_and_multiply2(self, mock_multiply):
x = 3
y = 5
mock_multiply.return_value = 15
addition, multiple = function.add_and_multiply(x, y)
mock_multiply.assert_called_once_with(3, 5)
self.assertEqual(8, addition)
self.assertEqual(15, multiple)
if __name__ == "__main__":
unittest.main()
@patch("function.multiply")
patch()装饰/上下文管理器可以很容易地模拟类或对象在模块测试。在测试过程中，您指定的对象将被替换为一个模拟（或其他对象），并在测试结束时还原。
这里模拟function.py文件中multiply()函数。
def test_add_and_multiply2(self, mock_multiply):
在定义测试用例中，将mock的multiply()函数（对象）重命名为 mock_multiply对象。
mock_multiply.return_value = 15
设定mock_multiply对象的返回值为固定的15。
ock_multiply.assert_called_once_with(3, 5)
检查ock_multiply方法的参数是否正确。
再次，运行测试用例，通过！
---------------------------------------------------
❻ jmockit怎么mock 异常后面跟参数
做过几篇 JMockit 使用 Expectations 来 Mock 方法，私有方法，私有属性的的日志，今天工作上突然有个需求是要
Mock 异常。现在再也不能为了跑个单元测试而去拔下网线了，也不该人为的去制造其他混乱来测试。开始是想能不能用 Expectations 来
Mock 异常，尚未发现相关的属性可以设置，没有类似 result 那样的属性，比如想象中有个 exception/throwable 属性：
new Expectations(MyService.class, ExternalService.class) {
{
ExternalService.fetchData();
throwable = new NetworkException("No IPAddress ");
} };
可是没有 throwable 个属性，至少我还不知道如何用 Expectations 来 Mock 异常，此路不通，所以只得另辟溪径。我们可以直接 new MockUp 来创建类，这比创建一个 MockClass 来得轻量级些。
下面是一个完整例子，由四个类构成，今次列出
1. 要抛出的异常类 NetworkException.java
package cc.unmi;
public class NetworkException extends RuntimeException {
public NetworkException(String message) {
super(message);
}
}
2. 被测试类 MyService.java
package cc.unmi;
public class MyService {
public static String fetchData(String name) {
return ExternalService.fetchByHttp(name);
}
}
调用 ExternalService.fetchByHttp() 方法，我们的测试用例将要 Mock 住这个方法，并抛出 NetworkException 异常。
3. 外部类，待 Mock 的 ExternalService.java
package cc.unmi;
public class ExternalService {
public static String fetchByHttp(String name) {
String result = null;
try {
// do something
} catch (Exception ex) {
throw new NetworkException(ex.getMessage());
}
return result;
}
}
这是个示例方法，就上面的代码正常执行时肯定不会抛出 NetworkException 异常。我们假定在 //do something 的代码可能会抛出 NetworkException 异常，但我们可以在 Mock 方法中立即呈现出这个异常来。
本文原始链接 http://unmi.cc/jmockit-how-to-mock-excepction/
, 来自隔叶黄莺 Unmi Blog
4. 测试类 MyService.java，并完成异常的 Mock
package cc.unmi;
import mockit.Mock;
import mockit.MockUp;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
public class MyServiceTest {
@Rule
public ExpectedException expectedEx = ExpectedException.none();
@Test
public void testFetchData() {
new MockUp<ExternalService>() {
@Mock
public String fetchByHttp(String name) {
throw new NetworkException("No IPAddress");
}
};
expectedEx.expect(NetworkException.class);
expectedEx.expectMessage("No IPAddress");
MyService.fetchData("Yanbin");
}
}
这里用 new MockUp<>(){@Mock...}
的方式来 Mock 方法，我们也可以用 @MockClass..@Mock
的方式来创建 Mock 类/方法，但要笨重些。目前我们项目中基本摒弃了用 @MockClass 创建外部 Mock 类的做法，因为一般 Mock 类一般是与某一个测试方法紧密联系着的。
也要注意到 fetchByHttp() 本是个静态方法，但此处不能写成 public String static fetchByHttp(), 但去掉 static 也不会影响到 Mock 的效果。
JUnit 关于异常的测试可以参考 JUnit 4 如何正确测试异常
。
测试运行成功，能够断言到所期待的异常类型和消息。
下面为演示 Mock 异常的正确而有效性，故意把 expectedEx.epectMessage("No IPAddress")
改成 expectedEx.epectMessage("NoNo IPAddress")
，这样 JUnit 更能爆出有助于理解的错误信息来
上面的错误信息告诉我们
第一个断言 expectedEx.expect(NetworkException.class)
是成功的
期待错误消息 NoNo IPAddress
，但得到的是 No IPAddress
，这正好从反面说明了我们 Mock 异常是成功的。
❼ mockplus怎么修改手机尺寸
方法/步骤
首先我们需要安装mockplus的客户端，其实在Web也可以制作，不过客户端方便一下。然后点击进入，可以选择新建一个项目，也可以看他的一些例子学习一下别人的设计
新建之后，会进入一个选择界面，上面是各种型号的选择，手机还是pad或者网页版，还分为mac和windows，可以自行选择，也可以自定义尺寸
点击mockplus，可以看到有选项部分，可以进入这个选项进行整体上面的设计，比如UI的透明度，背景颜色等。通过设置让自己设计更为顺心
然后可以看到左边会有两个部分，一个是各种各样的部件，一个编辑的地方。可以根据自己的需要把部件拉到自己需要的地方。
拉好部件之后，可以根据需要进行备注说明，可以点击小闪电进行超链接，也可以进行尺寸上面的设置。
左边是各种各样的页面，我们可以根据自己的需要进行页面链接的设置。注意mockplus只允许页面跳转而不允许部件跳转，好了之后，点击上面的运行，一个APP线框图就生成了
❽ 怎么mockito方法的内部对象
怎么mockito方法的内部对象？Mockito是一个针对Java的mocking框架。它与EasyMock和jMock很相似，但是通过在执行后校验什么已经被调用，它消除了对期望行为（expectations）的需要。其它的mocking库需要你在执行前记录期望行为（expectations），而这导致了丑陋的初始化代码。下文为转载，但原文有问题，错误的地方特地标红了
Introction
Code in which new objects are created can be difficult to test. There are a number of patterns for doing this; two of them are discussed here. Both of these patterns may require rearranging your code a little, to make it more testable. Writing code that's easily testable is a good thing to be doing, regardless of which mocking framework you end up using.
Details
Pattern 1 involves factoring uses of new into one-line methods, then using a Mockito spy. This is the simpler of the two patterns. Pattern 2 involves factoring uses of new into a separate class and injecting it. It's a little more work, but it can be more powerful. The new calls that you want to factor out (using either pattern) are those where an object is created, that you are likely to want to mock. It is recommended that you use one or other of these patterns, whenever you find yourself writing new, on a class that's in your code base (as opposed to a JDK class or a class from a third party library).
❾ moickito 怎么只mock部分属性
因为Mockito使用继承的方式实现mock的，用CGLIB生成mock对象代替真实的对象进行执行，为了mock实例的方法，你可以在subclass中覆盖它，而static方法是不能被子类覆盖的，所以Mockito不能mock静态方法。
但PowerMock可以mock静态方法，因为它直接在bytecode上工作，类似这样：
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.moles.testng.PowerMockTestCase;
import org.testng.Assert;
import org.testng.annotations.Test;
@PrepareForTest(AbstractAnimal.class)
public class AbstractAnimalTest extends PowerMockTestCase {
@Test
public void shouldGetMockedHello() {
PowerMockito.mockStatic(AbstractAnimal.class);
PowerMockito.when(AbstractAnimal.getHello()).thenReturn(Hello mocked animal world!);
String greetings = AbstractAnimal.getHello();
Assert.assertTrue(greetings.equals(Hello mocked animal world!));
}
}
❿ 如何使用Mock来测试Files，Database和ContentProviders
Android是如何实现应用程序之间数据共享的？一个应用程序可以将自己的数据完全暴露出去，外界更本看不到，也不用看到这个应用程序暴露的数据是如何存储的，或者是使用数据库还是使用文件，还是通过网上获得，这些一切都不重要，重要的是外界可以通过这一套标准及统一的接口和这个程序里的数据打交道，例如：添加(insert)、删除(delete)、查询(query)、修改(update)，当然需要一定的权限才可以。如何将应用程序的数据暴露出去？Android提供了ContentProvider，一个程序可以通过实现一个Contentprovider的抽象接口将自己的数据完全暴露出去，而且Contentproviders是以类似数据库中表的方式将数据暴露。Contentproviders存储和检索数据，通过它可以让所有的应用程序访问到，这也是应用程序之间唯一共享数据的方法。要想使应用程序的数据公开化，可通过2种方法：创建一个属于你自己的Contentprovider或者将你的数据添加到一个已经存在的Contentprovider中，前提是有相同数据类型并且有写入Contentprovider的权限。如何通过一套标准及统一的接口获取其他应用程序暴露的数据？Android提供了ContentResolver，外界的程序可以通过ContentResolver接口访问ContentProvider提供的数据。当前篇主要说明，如何获取其它应用程序共享的数据，比如获取Android手机电话薄中的信息。什么是URI？在学习如何获取ContentResolver前，有个名词是必须了解的：URI。URI是网络资源的定义，在Android中赋予其更广阔的含义，先看个例子，如下：将其分为A，B，C，D4个部分：A：标准前缀，用来说明一个ContentProvider控制这些数据，无法改变的；B：URI的标识，它定义了是哪个ContentProvider提供这些数据。对于第三方应用程序，为了保证URI标识的唯一性，它必须是一个完整的、小写的类名。这个标识在元素的authorities属性中说明：C：路径，ContentProvider使用这些路径来确定当前需要生什么类型的数据，URI中可能不包括路径，也可能包括多个；D：如果URI中包含，表示需要获取的记录的ID；如果没有ID，就表示返回全部；由于URI通常比较长，而且有时候容易出错，切难以理解。所以，在Android当中定义了一些辅助类，并且定义了一些常量来代替这些长字符串，例如：People.CONTENT_URIContentResolver介绍说明看完这些介绍，大家一定就明白了，ContentResolver是通过URI来查询ContentProvider中提供的数据。除了URI以外，还必须知道需要获取的数据段的名称，以及此数据段的数据类型。如果你需要获取一个特定的记录，你就必须知道当前记录的ID，也就是URI中D部分。前面也提到了Contentproviders是以类似数据库中表的方式将数据暴露出去，那么ContentResolver也将采用类似数据库的操作来从Contentproviders中获取数据。现在简要介绍ContentResolver的主要接口，如下：返回值函数声明finalUriinsert(Uriurl,ContentValuesvalues).finalintdelete(Uriurl,Stringwhere,String[]selectionArgs)Deletesrow(s)specifiedbyacontentURI.finalCursorquery(Uriuri,String[]projection,Stringselection,String[]selectionArgs,StringsortOrder)QuerythegivenURI,.finalintupdate(Uriuri,ContentValuesvalues,Stringwhere,String[]selectionArgs)Updaterow(s)inacontentURI.看到这里，是否感觉与数据库的操作基本一样的？就是这样的，详细解析请参考AndroidSQLite解析篇中的说明，不在此详细说明。最后一个问题：如何获取ContentResolver？调用getContentResolver()，例如：ContentResolvercr=getContentResolver();制作ContentResolver实例以上就完全介绍了如何获取、使用ContentResolver，启动Eclipes，制作一个完整的实例如下：打开showcontent.java，修改如下：packagemoandroid.showcontact;importandroid.app.ListActivity;importandroid.database.Cursor;importandroid.os.Bundle;importandroid.provider.Contacts.Phones;importandroid.widget.ListAdapter;importandroid.widget.SimpleCursorAdapter;{protectedvoidonCreate(BundlesavedInstanceState){super.onCreate(savedInstanceState);//ContentResolver通过URI来查询ContentProvider中提供的数据Cursorc=getContentResolver().query(Phones.CONTENT_URI,null,null,null,null);startManagingCursor(c);ListAdapteradapter=newSimpleCursorAdapter(this,android.R.layout.simple_list_item_2,c,newString[]{Phones.NAME,Phones.NUMBER},newint[]{android.R.id.text1,android.R.id.text2});setListAdapter(adapter);}}然后在AndroidManifest.XML中元素前增加如下许可:最后运行程序，在模拟器启动后，单击Menu返回到Home界面，打开Contacts选择Contacts标签页，添加2个联系人信息。返回到Home，选择moandroid.showcontact运行，刚添加的2个联系人信息将显示在界面上