Android常用的8种设计模式
一般来说,常用的android设计模式有以下8种:适配器、工厂、单例、观察者、代理、命令、组合、访问者。
设计模式之Adapter(适配器模式)
定义:将两个不兼容的类纠合在一起使用,属于结构型模式,需要有Adaptee(被适配者)和Adaptor(适配器)两个身份.
为何使用:我们经常碰到要将两个没有关系的类组合在一起使用,第一解决方案是:修改各自类的接口,但是如果我们没有源代码,或者,我们不愿意为了一个应用而修改各自的接口。怎么办:使用Adapter,在这两种接口之间创建一个混合接口(混血儿).
如何使用:实现Adapter方式,其实"think in Java"的"类再生"一节中已经提到,有两种方式:组合(composition)和继承(inheritance).
假设我们要打桩,有两种类:方形桩圆形桩.
public class SquarePeg{
public void insert(String str){
System.out.println("SquarePeg insert():"+str);
}
}
public class RoundPeg{
public void insertIntohole(String msg){
System.out.println("RoundPeg insertIntoHole():"+msg);
}
}
现在有一个应用,需要既打方形桩,又打圆形桩.那么我们需要将这两个没有关系的类综合应用.假设RoundPeg我们没有源代码,或源代码我们不想修改,那么我们使用Adapter来实现这个应用:
public class PegAdapter extends SquarePeg{
private RoundPeg roundPeg;
public PegAdapter(RoundPeg peg)(this.roundPeg=peg;)
public void insert(String str){ roundPeg.insertIntoHole(str);} }
在上面代码中,RoundPeg属于Adaptee,是被适配者.PegAdapter是Adapter,将Adaptee(被适配者RoundPeg)和Target(目标SquarePeg)进行适配.实际上这是将组合方法(composition)和继承(inheritance)方法综合运用.
PegAdapter首先继承SquarePeg,然后使用new的组合生成对象方式,生成RoundPeg的对象roundPeg,再重载父类insert()方法。从这里,你也了解使用
new生成对象和使用extends继承生成对象的不同,前者无需对原来的类修改,甚至无需要知道其内部结构和源代码.
如果你有些Java使用的经验,已经发现,这种模式经常使用。
进一步使用上面的PegAdapter是继承了SquarePeg,如果我们需要两边继承,即继承SquarePeg 又继承RoundPeg,因为Java中不允许多继承,但是我们可以实现(implements)两个接口(interface)
public interface IRoundPeg{
public void insertIntoHole(String msg);
}
public interface ISquarePeg{
public void insert(String str);
}
下面是新的RoundPeg 和SquarePeg, 除了实现接口这一区别,和上面的没什么区别。
public class SquarePeg implements ISquarePeg{
public void insert(String str){
System.out.println("SquarePeg insert():"+str);
}
}
public class RoundPeg implements IRoundPeg{
public void insertIntohole(String msg){
System.out.println("RoundPeg insertIntoHole():"+msg);
}
}
下面是新的PegAdapter,叫做two-way adapter:
public class PegAdapter implements IRoundPeg,ISquarePeg{
private RoundPeg roundPeg;
private SquarePeg squarePeg;
// 构造方法
public PegAdapter(RoundPeg peg){this.roundPeg=peg;}
// 构造方法
public PegAdapter(SquarePeg peg)(this.squarePeg=peg;)
public void insert(String str){ roundPeg.insertIntoHole(str);} }
还有一种叫Pluggable Adapters,可以动态的获取几个adapters中一个。使用Reflection技术,可以动态的发现类中的Public方法。
设计模式之Factory(工厂模式)
定义:提供创建对象的接口.
为何使用:工厂模式是我们最常用的模式了,著名的Jive论坛 ,就大量使用了工厂模式,工厂模式在Java程序系统可以说是随处可见。
为什么工厂模式是如此常用:因为工厂模式就相当于创建实例对象的new,我们经常要根据类Class生成实例对象,如A a=new A() 工厂模式也是用来创建实例对象的,所以以后new时就要多个心眼,是否可以考虑实用工厂模式,虽然这样做,可能多做一些工作,但会给你系统带来更大的可扩展性和尽量少的修改量。我们以类Sample为例,如果我们要创建Sample的实例对象:
Sample sample=new Sample();
可是,实际情况是,通常我们都要在创建sample实例时做点初始化的工作,比如赋值查询数据库等。
首先,我们想到的是,可以使用Sample的构造函数,这样生成实例就写成: Sample sample=new Sample(参数);
但是,如果创建sample实例时所做的初始化工作不是象赋值这样简单的事,可能是很长一段代码,如果也写入构造函数中,那你的代码很难看了(就需要Refactor重整)。
为什么说代码很难看,初学者可能没有这种感觉,我们分析如下,初始化工作如果是很长一段代码,说明要做的工作很多,将很多工作装入一个方法中,相当于将很多鸡蛋放在一个篮子里,是很危险的,这也是有背于Java面向对象的原则,面向对象的封装(Encapsulation)和分派(Delegation)告诉我们,尽量将长的代码分派“切割”成每段,将每段再“封装”起来(减少段和段之间偶合联系性),这样,就会将风险分散,以后如果需要修改,只要更改每段,不会再发生牵一动百的事情。
在本例中,首先,我们需要将创建实例的工作与使用实例的工作分开, 也就是说,让创建实例所需要的大量初始化工作从Sample的构造函数中分离出去。
这时我们就需要Factory工厂模式来生成对象了,不能再用上面简单new Sample(参数)。还有,如果Sample有个继承如MySample, 按照面向接口编程,我们需要将Sample抽象成一个接口.现在Sample是接口,有两个子类MySample 和HisSample .我们要实例化他们时,如下:
Sample mysample=new MySample();
Sample hissample=new HisSample();
随着项目的深入,Sample可能还会"生出很多儿子出来", 那么我们要对这些儿子一个个实例化,更糟糕的是,可能还要对以前的代码进行修改:加入后来生出儿子的实例.这在传统程序中是无法避免的.
但如果你一开始就有意识使用了工厂模式,这些麻烦就没有了.
工厂方法
你会建立一个专门生产Sample实例的工厂:
public class Factory{
public static Sample creator(int which){
//getClass 产生Sample 一般可使用动态类装载装入类。
if (which==1)
return new SampleA();
else if (which==2)
return new SampleB();
}
那么在你的程序中,如果要实例化Sample时.就使用
Sample sampleA=Factory.creator(1);
这样,在整个就不涉及到Sample的具体子类,达到封装效果,也就减少错误修改的机会,这个原理可以用很通俗的话来比喻:就是具体事情做得越多,越容易范错误.这每个做过具体工作的人都深有体会,相反,官做得越高,说出的话越抽象越笼统,范错误可能性就越少.好象我们从编程序中也能悟出人生道理?呵呵.
使用工厂方法要注意几个角色,首先你要定义产品接口,如上面的Sample,产品接口下有Sample接口的实现类,如SampleA,其次要有一个factory类,用来生成产品Sample,如下图,最右边是生产的对象Sample:
进一步稍微复杂一点,就是在工厂类上进行拓展,工厂类也有继承它的实现类concreteFactory了。
抽象工厂
工厂模式中有: 工厂方法(Factory Method) 抽象工厂(Abstract Factory). 这两个模式区别在于需要创建对象的复杂程度上。如果我们创建对象的方法变得复杂了,如上面工厂方法中是创建一个对象Sample,如果我们还有新的产品接口Sample2.
这里假设:Sample有两个concrete类SampleA和SamleB,而Sample2也有两个concrete类Sample2A和SampleB2
那么,我们就将上例中Factory变成抽象类,将共同部分封装在抽象类中,不同部分使用子类实现,下面就是将上例中的Factory拓展成抽象工厂:
public abstract class Factory{
public abstract Sample creator();
public abstract Sample2 creator(String name);
}
public class SimpleFactory extends Factory{
public Sample creator(){
.........
return new SampleA
}
public Sample2 creator(String name){
.........
return new Sample2A
}
public class BombFactory extends Factory{
public Sample creator(){
......
return new SampleB
}
public Sample2 creator(String name){
......
return new Sample2B
}
}
从上面看到两个工厂各自生产出一套Sample和Sample2,也许你会疑问,为什么
我不可以使用两个工厂方法来分别生产Sample和Sample2?
抽象工厂还有另外一个关键要点,是因为SimpleFactory内,生产Sample和
生产Sample2的方法之间有一定联系,所以才要将这两个方法捆绑在一个类中,
这个工厂类有其本身特征,也许制造过程是统一的,比如:制造工艺比较简单,
所以名称叫SimpleFactory。
在实际应用中,工厂方法用得比较多一些,而且是和动态类装入器组合在一起应
用,
举例
我们以Jive的ForumFactory为例,这个例子在前面的Singleton模式中我们讨
论过,现在再讨论其工厂模式:
public abstract class ForumFactory {
private static Object initLock = new Object();
private static String className = "com.jivesoftware.forum.database.DbForumFactory";
private static ForumFactory factory = null;
public static ForumFactory getInstance(Authorization authorization) { //If no valid authorization passed in, return null.
if (authorization == null) {
return null;
}
//以下使用了Singleton 单态模式
if (factory == null) {
synchronized(initLock) {
if (factory == null) {
......
try {
//动态转载类
Class c = Class.forName(className);
factory = (ForumFactory)c.newInstance();
}
catch (Exception e) {
return null;
}
}
}
}
//Now, 返回 proxy.用来限制授权对forum的访问
return new ForumFactoryProxy(authorization, factory,
factory.getPermissions(authorization));
}
//真正创建forum的方法由继承forumfactory的子类去完成.
public abstract Forum createForum(String name, String description)
throws UnauthorizedException, ForumAlreadyExistsException;
....
}
因为现在的Jive是通过数据库系统存放论坛帖子等内容数据,如果希望更改为
通过文件系统实现,这个工厂方法ForumFactory就提供了提供动态接口:
private static String className =
"com.jivesoftware.forum.database.DbForumFactory";
你可以使用自己开发的创建forum的方法代替
com.jivesoftware.forum.database.DbForumFactory就可以.
在上面的一段代码中一共用了三种模式,除了工厂模式外,还有Singleton单态
模式,以及proxy模式,proxy模式主要用来授权用户对forum的访问,因为访问
forum有两种人:一个是注册用户一个是游客guest,那么那么相应的权限就不
一样,而且这个权限是贯穿整个系统的,因此建立一个proxy,类似网关的概念,
可以很好的达到这个效果.
看看Java宠物店中的CatalogDAOFactory:
public class CatalogDAOFactory {
/**
* 本方法制定一个特别的子类来实现DAO模式。
* 具体子类定义是在J2EE的部署描述器中。
*/
public static CatalogDAO getDAO() throws CatalogDAOSysException { CatalogDAO catDao = null;
try {
InitialContext ic = new InitialContext();
//动态装入CATALOG_DAO_CLASS
//可以定义自己的CATALOG_DAO_CLASS,从而在无需变更太多代码
//的前提下,完成系统的巨大变更。
String className =(String) ic.lookup(JNDINames.CATALOG_DAO_CLASS);
catDao = (CatalogDAO) Class.forName(className).newInstance();
} catch (NamingException ne) {
throw new CatalogDAOSysException("
CatalogDAOFactory.getDAO: NamingException while
getting DAO type : \n" + ne.getMessage());
} catch (Exception se) {
throw new CatalogDAOSysException("
CatalogDAOFactory.getDAO: Exception while getting
DAO type : \n" + se.getMessage());
}
return catDao;
}
}
CatalogDAOFactory是典型的工厂方法,catDao是通过动态类装入器className 获得CatalogDAOFactory具体实现子类,这个实现子类在Java宠物店是用来操作catalog数据库,用户可以根据数据库的类型不同,定制自己的具体实现子类,将自己的子类名给与CATALOG_DAO_CLASS变量就可以。
由此可见,工厂方法确实为系统结构提供了非常灵活强大的动态扩展机制,只要我们更换一下具体的工厂方法,系统其他地方无需一点变换,就有可能将系统功能进行改头换面的变化。
设计模式之Singleton(单例模式)
定义:Singleton模式主要作用是保证在Java应用程序中,一个类Class只有一个实例存在。在很多操作中,比如建立目录数据库连接都需要这样的单线程操作。还有, singleton能够被状态化; 这样,多个单态类在一起就可以作为一个状态仓库一样向外提供服务,比如,你要论坛中的帖子计数器,每次浏览一次需要计数,单态类能否保持住这个计数,并且能synchronize的安全自动加1,如果你要把这个数字永久保存到数据库,你可以在不修改单态接口的情况下方便的做到。
另外方面,Singleton也能够被无状态化。提供工具性质的功能,
Singleton模式就为我们提供了这样实现的可能。使用Singleton的好处还在于可以节省内存,因为它限制了实例的个数,有利于Java垃圾回收(garbage collection)。
我们常常看到工厂模式中类装入器(class loader)中也用Singleton模式实现的,因为被装入的类实际也属于资源。
如何使用?
一般Singleton模式通常有几种形式:
public class Singleton {
private Singleton(){}
//在自己内部定义自己一个实例,是不是很奇怪?
//注意这是private 只供内部调用
private static Singleton instance = new Singleton();
//这里提供了一个供外部访问本class的静态方法,可以直接访问
public static Singleton getInstance() {
return instance;
}
}
第二种形式:
public class Singleton {
private static Singleton instance = null;
public static synchronized Singleton getInstance() {
//这个方法比上面有所改进,不用每次都进行生成对象,只是第一次
//使用时生成实例,提高了效率!
if (instance==null)
instance=new Singleton();
return instance; }
}
使用Singleton.getInstance()可以访问单态类。
上面第二中形式是lazy initialization,也就是说第一次调用时初始Singleton,以后就不用再生成了。
注意到lazy initialization形式中的synchronized,这个synchronized很重要,如果没有synchronized,那么使用getInstance()是有可能得到多个Singleton实例。关于lazy initialization的Singleton有很多涉及double-checked locking (DCL)的讨论,有兴趣者进一步研究。
一般认为第一种形式要更加安全些。
使用Singleton注意事项:
有时在某些情况下,使用Singleton并不能达到Singleton的目的,如有多个Singleton对象同时被不同的类装入器装载;在EJB这样的分布式系统中使用也要注意这种情况,因为EJB是跨服务器,跨JVM的。
我们以SUN公司的宠物店源码(Pet Store 1.3.1)的ServiceLocator为例稍微分析一下:
在Pet Store中ServiceLocator有两种,一个是EJB目录下;一个是WEB目录下,我们检查这两个ServiceLocator会发现内容差不多,都是提供EJB的查询定位服务,可是为什么要分开呢?仔细研究对这两种ServiceLocator才发现区别:在WEB中的ServiceLocator的采取Singleton模式,ServiceLocator属于资源定位,理所当然应该使用Singleton模式。但是在EJB中,Singleton模式已经失去作用,所以ServiceLocator才分成两种,一种面向WEB服务的,一种是面向EJB服务的。
Singleton模式看起来简单,使用方法也很方便,但是真正用好,是非常不容易,需要对Java的类线程内存等概念有相当的了解。
进一步深入可参考:
Double-checked locking and the Singleton pattern
When is a singleton not a singleton?
设计模式之Observer(观察者模式)
Java深入到一定程度,就不可避免的碰到设计模式(design pattern)这一概念,了解设计模式,将使自己对java中的接口或抽象类应用有更深的理解.设计模式在java的中型系统中应用广泛,遵循一定的编程模式,才能使自己的代码便于理解,易于交流,Observer(观察者)模式是比较常用的一个模式,尤其在界面设计中应用广泛,而本站所关注的是Java在电子商务系统中应用,因此想从电子商务实例中分析Observer的应用.
虽然网上商店形式多样,每个站点有自己的特色,但也有其一般的共性,单就"商品的变化,以便及时通知订户"这一点,是很多网上商店共有的模式,这一模式类似Observer patern.
具体的说,如果网上商店中商品在名称价格等方面有变化,如果系统能自动通知会员,将是网上商店区别传统商店的一大特色.这就需要在商品product中加入Observer这样角色,以便product细节发生变化时,Observer能自动观察到这种变化,并能进行及时的update或notify动作.
Java的API还为为我们提供现成的Observer接口Java.util.Observer.我们只要直接使用它就可以.
我们必须extends Java.util.Observer才能真正使用它:
1.提供Add/Delete observer的方法;
2.提供通知(notisfy) 所有observer的方法;
//产品类可供Jsp直接使用UseBean调用该类主要执行产品数据库插
入更新
public class product extends Observable{
private String name;
private float price;
public String getName(){ return name;}
public void setName(){
https://www.wendangku.net/doc/7212410544.html,=name;
//设置变化点
setChanged();
notifyObservers(name);
}
public float getPrice(){ return price;}
public void setPrice(){
this.price=price;
//设置变化点
setChanged();
notifyObservers(new Float(price));
}
//以下可以是数据库更新插入命令.
public void saveToDb(){
.....................
}
我们注意到,在product类中的setXXX方法中,我们设置了 notify(通知)方法, 当Jsp表单调用setXXX(如何调用见我的另外一篇文章),实际上就触发了notisfyObservers方法,这将通知相应观察者应该采取行动了.
下面看看这些观察者的代码,他们究竟采取了什么行动:
//观察者NameObserver主要用来对产品名称(name)进行观察的
public class NameObserver implements Observer{
private String name=null;
public void update(Observable obj,Object arg){
if (arg instanceof String){
name=(String)arg;
//产品名称改变值在name中
System.out.println("NameObserver :name changet to "+name);
}
}
}
//观察者PriceObserver主要用来对产品价格(price)进行观察的
public class PriceObserver implements Observer{
private float price=0;
public void update(Observable obj,Object arg){
if (arg instanceof Float){
price=((Float)arg).floatValue();
System.out.println("PriceObserver :price changet to "+price);
}
}
}
Jsp中我们可以来正式执行这段观察者程序:
<%
if (request.getParameter("save")!=null)
{
product.saveToDb();
out.println("产品数据变动保存! 并已经自动通知客户");
}else{
//加入观察者
product.addObserver(nameobs);
product.addObserver(priceobs);
%>
//request.getRequestURI()是产生本jsp的程序名,就是自己调用自己
<%
}
%>
执行改Jsp程序,会出现一个表单录入界面, 需要输入产品名称产品价格, 点按Submit后,还是执行该jsp的
if (request.getParameter("save")!=null)之间的代码.
由于这里使用了数据javabeans的自动赋值概念,实际程序自动执行了setName setPrice语句.你会在服务器控制台中发现下面信息::
NameObserver :name changet to ?????(Jsp表单中输入的产品名称)
PriceObserver :price changet to ???(Jsp表单中输入的产品价格);
这说明观察者已经在行动了.!!
同时你会在执行jsp的浏览器端得到信息:
产品数据变动保存! 并已经自动通知客户
上文由于使用jsp概念,隐含很多自动动作,现将调用观察者的Java代码写如下:
public class Test {
public static void main(String args[]){
Product product=new Product();
NameObserver nameobs=new NameObserver();
PriceObserver priceobs=new PriceObserver();
//加入观察者
product.addObserver(nameobs);
product.addObserver(priceobs);
product.setName("橘子红了");
product.setPrice(9.22f);
}
}
你会在发现下面信息::
NameObserver :name changet to 橘子红了
PriceObserver :price changet to 9.22
这说明观察者在行动了.!!
设计模式之Proxy(代理模式)
理解并使用设计模式,能够培养我们良好的面向对象编程习惯,同时在实际应用中,可以如鱼得水,享受游刃有余的乐趣.
Proxy是比较有用途的一种模式,而且变种较多,应用场合覆盖从小结构到整个系统的大结构,Proxy是代理的意思,我们也许有代理服务器等概念,代理概念可以解释为:在出发点到目的地之间有一道中间层,意为代理.
设计模式中定义: 为其他对象提供一种代理以控制对这个对象的访问.
为什么要使用Proxy?
1.授权机制不同级别的用户对同一对象拥有不同的访问权利,如Jive论坛系统
中,就使用Proxy进行授权机制控制,访问论坛有两种人:注册用户和游客(未注册用户),Jive中就通过类似ForumProxy这样的代理来控制这两种用户对论坛的访问权限.
2.某个客户端不能直接操作到某个对象,但又必须和那个对象有所互动.
举例两个具体情况:
(1)如果那个对象是一个是很大的图片,需要花费很长时间才能显示出来,那么当这个图片包含在文档中时,使用编辑器或浏览器打开这个文档,打开文档必须很迅速,不能等待大图片处理完成,这时需要做个图片Proxy来代替真正的图片.
(2)如果那个对象在Internet的某个远端服务器上,直接操作这个对象因为网络速度原因可能比较慢,那我们可以先用Proxy来代替那个对象.
总之原则是,对于开销很大的对象,只有在使用它时才创建,这个原则可以为我们节省很多宝贵的Java内存. 所以,有些人认为Java耗费资源内存,我以为这和程序编制思路也有一定的关系.
如何使用Proxy?
以Jive论坛系统为例,访问论坛系统的用户有多种类型:注册普通用户论坛管理者系统管理者游客,注册普通用户才能发言;论坛管理者可以管理他被授权的论坛;系统管理者可以管理所有事务等,这些权限划分和管理是使用Proxy完成的.
Forum是Jive的核心接口,在Forum中陈列了有关论坛操作的主要行为,如论坛名称论坛描述的获取和修改,帖子发表删除编辑等.
在ForumPermissions中定义了各种级别权限的用户:
public class ForumPermissions implements Cacheable {
/**
* Permission to read object.
*/
public static final int READ = 0;
/**
* Permission to administer the entire sytem.
*/
public static final int SYSTEM_ADMIN = 1;
/**
* Permission to administer a particular forum.
*/
public static final int FORUM_ADMIN = 2;
/**
* Permission to administer a particular user.
*/
public static final int USER_ADMIN = 3;
/**
* Permission to administer a particular group.
*/
public static final int GROUP_ADMIN = 4;
/**
* Permission to moderate threads.
*/
public static final int MODERATE_THREADS = 5;
/**
* Permission to create a new thread.
*/
public static final int CREATE_THREAD = 6;
/**
* Permission to create a new message.
*/
public static final int CREATE_MESSAGE = 7;
/**
* Permission to moderate messages.
*/
public static final int MODERATE_MESSAGES = 8;
.....
public boolean isSystemOrForumAdmin() {
return (values[FORUM_ADMIN] ||
values[SYSTEM_ADMIN]);
}
.....
}
因此,Forum中各种操作权限是和ForumPermissions定义的用户级别有关系的,作为接口Forum的实现:ForumProxy正是将这种对应关系联系起来.比如,修改Forum的名称,只有论坛管理者或系统管理者可以修改,代码如下:
public class ForumProxy implements Forum {
private ForumPermissions permissions;
private Forum forum;
this.authorization = authorization;
public ForumProxy(Forum forum, Authorization
authorization,
ForumPermissions permissions)
{
this.forum = forum;
this.authorization = authorization;
this.permissions = permissions;
}
.....
public void setName(String name) throws UnauthorizedException,
ForumAlreadyExistsException
{
//只有是系统或论坛管理者才可以修改名称
if (permissions.isSystemOrForumAdmin()) {
forum.setName(name);
}
else {
throw new UnauthorizedException();
}
}
...
}
而DbForum才是接口Forum的真正实现,以修改论坛名称为例:
public class DbForum implements Forum, Cacheable {
...
public void setName(String name) throws ForumAlreadyExistsException {
....
https://www.wendangku.net/doc/7212410544.html, = name;
//这里真正将新名称保存到数据库中
saveToDb();
....
}
...
}
凡是涉及到对论坛名称修改这一事件,其他程序都首先得和ForumProxy打交道,由ForumProxy决定是否有权限做某一样事情,ForumProxy是个名副其实的"网关","安全代理系统".
在平时应用中,无可避免总要涉及到系统的授权或安全体系,不管你有无意识的使用Proxy,实际你已经在使用Proxy了.
我们继续结合Jive谈入深一点,下面要涉及到工厂模式了,如果你不了解工厂模式,请看我的另外一篇文章:设计模式之Factory
我们已经知道,使用Forum需要通过ForumProxy,Jive中创建一个Forum是使用Factory模式,有一个总的抽象类ForumFactory,在这个抽象类中,调用ForumFactory是通过getInstance()方法实现,这里使用了Singleton(也是设计模式之一,由于介绍文章很多,我就不写了,看这里),getInstance()返回的是ForumFactoryProxy.
为什么不返回ForumFactory,而返回ForumFactory的实现ForumFactoryProxy? 原因是明显的,需要通过代理确定是否有权限创建forum.
在ForumFactoryProxy中我们看到代码如下:
public class ForumFactoryProxy extends ForumFactory {
protected ForumFactory factory;
protected Authorization authorization;
protected ForumPermissions permissions;
public ForumFactoryProxy(Authorization authorization, ForumFactory factory,
ForumPermissions permissions)
{
this.factory = factory;
this.authorization = authorization;
this.permissions = permissions;
}
public Forum createForum(String name, String description)
throws UnauthorizedException, ForumAlreadyExistsException
{
//只有系统管理者才可以创建forum
if (permissions.get(ForumPermissions.SYSTEM_ADMIN)) {
Forum newForum = factory.createForum(name, description);
return new ForumProxy(newForum, authorization, permissions);
}
else {
throw new UnauthorizedException();
}
}
方法createForum返回的也是ForumProxy, Proxy就象一道墙,其他程序只能和Proxy交互操作.
注意到这里有两个Proxy:ForumProxy和ForumFactoryProxy. 代表两个不同的职责:使用Forum和创建Forum;
至于为什么将使用对象和创建对象分开,这也是为什么使用Factory模式的原因所在:是为了"封装""分派";换句话说,尽可能功能单一化,方便维护修改.
Jive论坛系统中其他如帖子的创建和使用,都是按照Forum这个思路而来的.
以上我们讨论了如何使用Proxy进行授权机制的访问,Proxy还可以对用户隐藏另外一种称为copy-on-write的优化方式.拷贝一个庞大而复杂的对象是一个开销很大的操作,如果拷贝过程中,没有对原来的对象有所修改,那么这样的拷贝开销就没有必要.用代理延迟这一拷贝过程.
比如:我们有一个很大的Collection,具体如hashtable,有很多客户端会并发同时访问它.其中一个特别的客户端要进行连续的数据获取,此时要求其他客户端不能再向hashtable中增加或删除东东.
最直接的解决方案是:使用collection的lock,让这特别的客户端获得这个lock,进行连续的数据获取,然后再释放lock.
public void foFetches(Hashtable ht){
synchronized(ht){
//具体的连续数据获取动作..
}
}
但是这一办法可能锁住Collection会很长时间,这段时间,其他客户端就不能访问该Collection了.
第二个解决方案是clone这个Collection,然后让连续的数据获取针对clone出来的那个Collection操作.这个方案前提是,这个Collection是可clone的,而且必须有提供深度clone的方法.Hashtable就提供了对自己的clone方法,但不是Key和value对象的clone,关于Clone含义可以参考专门文章.
public void foFetches(Hashtable ht){
Hashttable newht=(Hashtable)ht.clone();
}
问题又来了,由于是针对clone出来的对象操作,如果原来的母体被其他客户端操作修改了, 那么对clone出来的对象操作就没有意义了.
最后解决方案:我们可以等其他客户端修改完成后再进行clone,也就是说,这个特别的客户端先通过调用一个叫clone的方法来进行一系列数据获取操作.但实际上没有真正的进行对象拷贝,直至有其他客户端修改了这个对象Collection. 使用Proxy实现这个方案.这就是copy-on-write操作.
Proxy应用范围很广,现在流行的分布计算方式RMI和Corba等都是Proxy模式的应用.
更多Proxy应用,见https://www.wendangku.net/doc/7212410544.html,/~tarr/cs491/lectures/Proxy.pdf
Sun公司的Explore the Dynamic Proxy API Dynamic Proxy Classes
设计模式之Command(命令模式)
Command模式是最让我疑惑的一个模式,我在阅读了很多代码后,才感觉隐约掌握其大概原理,我认为理解设计模式最主要是掌握起原理构造,这样才对自己实际编程有指导作用.Command模式实际上不是个很具体,规定很多的模式,正是这个灵活性,让人有些confuse.
Command定义:不少Command模式的代码都是针对图形界面的,它实际就是菜单命令,我们在一个下拉菜单选择一个命令时,然后会执行一些动作.
将这些命令封装成在一个类中,然后用户(调用者)再对这个类进行操作,这就是Command模式,换句话说,本来用户(调用者)是直接调用这些命令的,如菜单上打开文档(调用者),就直接指向打开文档的代码,使用Command模式,就是在这两者之间增加一个中间者,将这种直接关系拗断,同时两者之间都隔离,基本没有关系了.
显然这样做的好处是符合封装的特性,降低耦合度,Command是将对行为进行封装的典型模式,Factory是将创建进行封装的模式,
从Command模式,我也发现设计模式一个"通病":好象喜欢将简单的问题复杂化, 喜欢在不同类中增加第三者,当然这样做有利于代码的健壮性可维护性还有复用性.
如何使用?
具体的Command模式代码各式各样,因为如何封装命令,不同系统,有不同的做法.下面事例是将命令封装在一个Collection的List中,任何对象一旦加入List 中,实际上装入了一个封闭的黑盒中,对象的特性消失了,只有取出时,才有可能模糊的分辨出:
典型的Command模式需要有一个接口.接口中有一个统一的方法,这就是"将命令/请求封装为对象":
public interface Command {
public abstract void execute ( );
}
具体不同命令/请求代码是实现接口Command,下面有三个具体命令
public class Engineer implements Command {
public void execute( ) {
//do Engineer's command
}
}
public class Programmer implements Command {
public void execute( ) {
//do programmer's command
}
}
public class Politician implements Command {
public void execute( ) {
//do Politician's command
}
}
按照通常做法,我们就可以直接调用这三个Command,但是使用Command模式,我们要将他们封装起来,扔到黑盒子List里去:
public class producer{
public static List produceRequests() {
List queue = new ArrayList();
queue.add( new DomesticEngineer() );
queue.add( new Politician() );
queue.add( new Programmer() );
return queue;
}
}
这三个命令进入List中后,已经失去了其外表特征,以后再取出,也可能无法分辨出谁是Engineer 谁是Programmer了,看下面如何调用Command模式:
public class TestCommand {
public static void main(String[] args) {
List queue = Producer.produceRequests();
for (Iterator it = queue.iterator(); it.hasNext(); )
//取出List中东东,其他特征都不能确定,只能保证
一个特征是100%正确,
// 他们至少是接口Command的"儿子".所以强制转换
类型为接口Command
((Command)it.next()).execute();
}
}
由此可见,调用者基本只和接口打交道,不合具体实现交互,这也体现了一个原则,面向接口编程,这样,以后增加第四个具体命令时,就不必修改调用者TestCommand中的代码了.
理解了上面的代码的核心原理,在使用中,就应该各人有自己方法了,特别是在如何分离调用者和具体命令上,有很多实现方法,上面的代码是使用"从List过一遍"的做法.这种做法只是为了演示.
使用Command模式的一个好理由还因为它能实现Undo功能.每个具体命令都可以记住它刚刚执行的动作,并且在需要时恢复.
Command模式在界面设计中应用广泛.Java的Swing中菜单命令都是使用Command模式,由于Java在界面设计的性能上还有欠缺,因此界面设计具体代码我们就不讨论,网络上有很多这样的示例.
参考:https://www.wendangku.net/doc/7212410544.html,/put/8/command.pdf
设计模式之Composite(组合模式)
Composite定义:将对象以树形结构组织起来,以达成“部分-整体”的层次结构,使得客户端对单个对象和组合对象的使用具有一致性.
Composite比较容易理解,想到Composite就应该想到树形结构图。组合体内这些对象都有共同接口,当组合体一个对象的方法被调用执行时,Composite将遍历(Iterator)整个树形结构,寻找同样包含这个方法的对象并实现调用执行。可以用牵一动百来形容。
所以Composite模式使用到Iterator模式,和Chain of Responsibility模式类似。
Composite好处:
1.使客户端调用简单,客户端可以一致的使用组合结构或其中单个对象,用户就不必关系自己处理的是单个对象还是整个组合结构,这就简化了客户端代码。
2.更容易在组合体内加入对象部件. 客户端不必因为加入了新的对象部件而更改代码。
如何使用Composite?
首先定义一个接口或抽象类,这是设计模式通用方式了,其他设计模式对接口内部定义限制不多,Composite却有个规定,那就是要在接口内部定义一个用于访问和管理Composite组合体的对象们(或称部件Component).
下面的代码是以抽象类定义,一般尽量用接口interface,
public abstract class Equipment
{
private String name;
//网络价格
public abstract double netPrice();
//折扣价格
public abstract double discountPrice();
//增加部件方法
public boolean add(Equipment equipment) { return false; }
//删除部件方法
public boolean remove(Equipment equipment) { return false; }
//注意这里,这里就提供一种用于访问组合体类的部件方法。
public Iterator iter() { return null; }
public Equipment(final String name) { https://www.wendangku.net/doc/7212410544.html,=name; }
}
抽象类Equipment就是Component定义,代表着组合体类的对象们,Equipment 中定义几个共同的方法。
public class Disk extends Equipment
{
public Disk(String name) { super(name); }
//定义Disk网络价格为1
public double netPrice() { return 1.; }
//定义了disk折扣价格是0.5 对折。
public double discountPrice() { return .5; }
}
Disk是组合体内的一个对象,或称一个部件,这个部件是个单独元素( Primitive)。
还有一种可能是,一个部件也是一个组合体,就是说这个部件下面还有'儿子',这是树形结构中通常的情况,应该比较容易理解。现在我们先要定义这个组合体:
abstract class CompositeEquipment extends Equipment
{
private int i=0;
//定义一个Vector 用来存放'儿子'
private Lsit equipment=new ArrayList();
public CompositeEquipment(String name) { super(name); }
通信实训报告 -Android移动平台开发 学院:信息工程学院 班级: 学号: 姓名:
实训内容: 一.1.Andriod的简介 Android一词的本义指“机器人”,同时也是Google于2007年11月5日宣布的基于Linux平台的开源手机操作系统的名称,该平台由操作系统、中间件、用户界面和应用软件组成,号称是首个为移动终端打造的真正开放和完整的移动软件。目前,最新版本为Android 2.4 Gingerbread 和Android 3.0 Honeycomb。 Android是基于Linux开放性内核的操作系统,是Google公司在2007年11月5日公布的手机操作系统。 Android早期由原名为"Android"的公司开发,谷歌在2005年收购"Android.Inc"后,继续对Android系统开发运营,它采用了软件堆层(software stack,又名软件叠层)的架构,主要分为三部分。底层Linux内核只提供基本功能,其他的应用软件则由各公司自行开发,部分程序以Java编写。2011年初数据显示,仅正式上市两年的操作系统Android已经超越称霸十年的塞班系统,使之跃居全球最受欢迎的智能手机平台。现在,Android系统不但应用于智能手机,也在平板电脑市场急速扩张,在智能MP4方面也有较大发展。采用Android系统主要厂商包括台湾的HTC,(第一台谷歌的手机G1由HTC生产代工)美国摩托罗拉,SE等,中国大陆厂商如:魅族(M9),华为、中兴、联想、蓝魔等。 2.Android构架图 二.1软件下载 Android SDK,网址是https://www.wendangku.net/doc/7212410544.html,. JDK的下载地址https://www.wendangku.net/doc/7212410544.html,/javase/downloads/widget/jdk6.jsp。Eclipse的下载网址是https://www.wendangku.net/doc/7212410544.html,/downloads/ 2.Android开发环境搭建
4.3.2 建表语句 1)创建: 1、创建书的表: create table IF NOT EXISTS book(bid integer primary key autoincrement,bpath varchar(255) not null); 2、创建书签的表: create table IF NOT EXISTS bookmark(bmid integer primary key autoincrement, bpath varchar(50) not null,bmname varchar(50) not null,bmoffset integer not null,bmsavetime varchar(20) not null); 3、创建用户管理的表: create table IF NOT EXISTS user(userid integer primary key autoincrement, username varchar(20) not null,password varchar(20) not null, telephone varchar(20) not null); 4、创建最近阅读的表 create table IF NOT EXISTS nearlyread(bookid integer primary key autoincrement, bookname varchar(50) not null,bookreadtime varchar(20) not null); 5、创建下载管理的表 create table IF NOT EXISTS down(downid integer primary key autoincrement, downuser varchar(20) not null,downbook varchar(20) not null, downtime varchar(20) not null); 2)SQlite3数据库使用方法: 选择:select from bookmark where bmid=1; 插入:insert (bookmark,null,values); 删除:delete from bookmark where bmid=3 ; 查找:query(table, columns, selection, selectionArgs, groupBy, having, orderBy) 4.3.3 数据表分析 本数据库用的是一个轻量级嵌入型数据库sqlite3 ,即创建了一个数据库reader.db,在数据库中创建了几张数据表。 在建设网站系统或者软件之前,我们必须对系统所用到的数据进行大致的分类和具体的结构设计,既要做到清晰明了,又要能适应系统各项功能的调用,而不至于产生结构上的逻辑混乱,保证关键数据在意外情况下不会被破坏,可以说
视图组件的使用模式 常用组件 高级组件 提示框与警告对话框
就是Android应用程序的开发过程。一般过程是先通过XML布局文件或Java代码创建界面布局,设定组件显示样式,随后获取UI组件对象,并处理组件事件响应。 视图组件的定义 资源的访问 生成视图组件资源标识 视图组件的引用 视图组件的事件响应 组件的常用属性
1.1视图组件的定义 使用XML布局文件定义视图组件 使用Java代码定义视图组件(不推荐)
1.1视图组件的定义 使用XML布局文件定义视图组件 Android平台为大多数视图组件以及其子类提供了XML标记,可通过XML布局文件中的标记来定义视图组件。XML中的每个元素代表了一个组件,即元素名称对应相应的Java类。
1.1视图组件的定义
这样的话就比较容易实现了,再看一下整体的Layout布局情况: xml布局文件如下:注意层次的嵌套。先是一个RelativeLayout,它有两个子布局,RelativeLayout和LinearLayout。 android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_centerInParent="true" android:padding="10.0dip" android:singleLine="true" android:text="设置" android:textColor="@color/white" android:textSize="15dp" />
基于Android系统的App界面设计 智能手机时代的来临改变了大多数人的生活习惯,时至今日智能手机已经成为了人们工作生活中的一部分,在工作生活中发挥着重要的作用。App作为智能手机应用程序的核心,构建以用户体验为核心的页面设计是智能手机App设计的核心与要点,同时也是满足用户使用需求的重要途径与方式。现今的智能手机App主要分为IOS与Android两大市场,与IOS的封闭不同的是Android系统具有极强的开放性,而这一开放性在为Android系统App带来无限可能的同时也使得基于Android系统所开发的App界面本身缺乏统一的规范,从而造成基于Android系统所开发的App界面具有极大的开放性。新时期为做好基于Android 系统App的设计需要从情感、认知以及感官三个层面入手做好基于Android系统的App界面的开发设计,使之具有良好的用户使用体验。 标签:Android系统;App;界面设计 Abstract:The advent of the smart phone era has changed the habits of most people. Today,smart phone s have become a part of people’s work and life,and play an important role in the work and life. As the core of smart phone applications,App plays an important role in the work and life. The design of page based on user experience is the core and key point of the App design of smart phone,and it is also an important way and way to meet the needs of users. Today’s smartphone App is mainly divided into IOS and Android two major markets,Different from the closure of IOS,Android system has a very strong openness,and this openness not only brings infinite possibility to App of Android system,but also makes the App interface based on Android system lack of unified specification. As a result,the App interface based on Android system is very open. In order to do well the design of App based on Android system in the new period,it is necessary to develop and design the App interface based on Android system from the three aspects of emotion,cognition and sense organ,to make it have a good user experience. Keywords:Android system;App;interface design 前言 Android系统是与IOS系统所并行的应用于智能手机中的两大智能系统,在基于Android系统App界面开发的过程中受多种因素的影响使得一些App的界面具有很大的不协调性,从而影响了广大用户的使用体验。本文在分析影响智能手机App界面设计因素的基础上对如何做好基于Android系统的App界面设计进行分析阐述。 1 影响智能手机App界面设计的因素分析 智能手机App是智能手机的灵魂,用户结合自身需求可以下载安装自身所
1.在android程序中,Log.d()用于输出什么级别的日志信息?(A) A、调试 B、信息 C、警告 D、错误 2.以下情况不会创建Context对象的是(C) A.创建Application 对象时 B.创建Service对象时 C.创建ContentProvider对象时 D.创建Activity对象时 3.下列不属于Android中广播中的类别的是(D) A.Normal Broadcas B.Sticky Broadcast C.Local Broadcast D.Order broadcast 4.以下哪个不是Intent的Activity启动方式(A) A.FLAG_ACTIVITY_BROUGHT_TO_FIRST B.FLAG_ACTIVITY_CLEAR_TOP C.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET D.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS 5.安卓AndroidManifest.xml文件的子节点不包括(C) A.application B.services C.permission D.provider 6.下面那个不是Fragment的生命周期方法(D) A. onStart B. onAttach C. onDestoryView D. onRestart 7.下面那种不是安卓原生支持的Menu(A) A.Selected Menu B.Option Menu C.Submenu D.Context Menu 8.下面不属于android的动画分类的有(D) A、Tween B、Frame C、Property D、Animation 9.下列哪个不是安卓service自带的方法(A) A.OnResume B.onCreate C.onStartCommand D.onRebind 10.下列属于SAX解析xml文件的优点的是(B) A、将整个文档树在内存中,便于操作,支持删除,修改,重新排列等多种功能 B、不用事先调入整个文档,占用资源少 C、整个文档调入内存,浪费时间和空间 D、不是长久驻留在内存,数据不是持久的,事件过后,若没有保存数据,数据就会消失 11.下列关于Soundpool和MediaPlayer的说法,错误的是(A) A.MediaPlayer支持多个音乐同时播放 B.MediaPlayer资源占用率高 C.MediaPlayer延迟时间较长 D.new MediaPlayer()后要调用prepare()方法才能播放 12.关于res/raw目录说法正确的是(A) A、这里的文件是原封不动的存储到设备上不会转换为二进制的格式
Android系统调研报告 摘要:Android手机操作系统自Google公司推出以来,经过两年的发展,已经成长为仅次于Aymbian的巨头,成为众多移动终端生产商和应用程序开发者青睐的选择。这次调研分析了Android系统的特点,介绍了Android系统构架、市场占有率、各版本的更新,以及对硬件的要求。简单分析了Android能取得成功的原因,以及Android的发展面临的困难和问题。 关键字:Android、智能手机系统、Android系统构架、Android版本、Android 发展问题 一、Android简介 Android 是Google历经数年和投资数亿美元开发出来的智能手机系统,是基于Linux内核的操作系统,是Google公司在2007年11月5日公布的手机操作系统。Google也发起了围绕Android的组织——开放手机联盟,其英文全称为“Open Handset Alliance”。它采用了软件堆层(software stack,又名以软件叠层)的架构,主要分为三部分。底层Linux内核只提供基本功能;其他的应用软件则由各公司自行开发,部分程序以Java编写。 随着各大移动终端生产商大力开发和生产基于Android的移动智能设备,Android迅速得到业界和社会的认可,并成为整个产业的热点,基于Android平台的各类人才逐渐成为各大企业竞相争夺的焦点。而且Android是一个开放的系统,不管是企业还是个人都可以参与来表达自己的创意和想法。
二、Android发展历程
三、Android特点 Android手机操作系统的推出,大大受到广大编程人员的喜爱。那么它究竟有什么出色的特点吸引着人们的眼光呢这里总结了一些Android特点,以供对此有兴趣的朋友参考学习。 1. Android是什么 Android是一个平台,主要包括Linux微内核,中间件(SQLite等),关键应用(电话本、邮件、短消息、GoogleMap、浏览器等),提供的Java框架,以及Android中的JVM。 特点之关键类 视图,ContentProviders(应用交互管理类)、ResourceManager非编码资源管理类、NotificationManager(通告管理类)、ActivityManager(生命周期管理类)。 特点之界面开发
https://www.wendangku.net/doc/7212410544.html,/cmdn/bbs/viewthread.php?tid=18736&page=1 #pid89255 Android UI开发专题(一) 之界面设计 近期很多网友对Android用户界面的设计表示很感兴趣,对于Android UI开发自绘控件和游戏制作而言掌握好绘图基础是必不可少的。本次专题分10节来讲述,有关OpenGL ES相关的可能将放到以后再透露。本次主要涉及以下四个包的相关内容:android.content.res 资源类 android.graphics 底层图形类 android.view 显示类 android.widget 控件类 一、android.content.res.Resources 对于Android平台的资源类android.content.res.Resources可能很多网友比较陌生,一起来看看SDK上是怎么介绍的吧,Contains classes for accessing application resources, such as raw asset files, colors, drawables, media or other other files in the package, plus important device configuration details (orientation, input types, etc.) that affect how the application may behave.平时用到的二进制源文件raw、颜色colors、图形drawables和多媒体文件media的相关资源均通过该类来管理。 int getColor(int id) 对应res/values/colors.xml Drawable getDrawable(int id) 对应res/drawable/ XmlResourceParser getLayout(int id) 对应res/layout/ String getString(int id) 和CharSequence getText(int id) 对应res/values/strings.xml InputStream openRawResource(int id) 对应res/raw/ void parseBundleExtra (String tagName, AttributeSet attrs, Bundle outBundle) 对应res/xml/ String[] getStringArray(int id) res/values/arrays.xml float getDimension(int id) res/values/dimens.xml 二、android.graphics.Bitmap 作为位图操作类,Bitmap提供了很多实用的方法,常用的我们总结如下: boolean compress(https://www.wendangku.net/doc/7212410544.html,pressFormat format, int quality, OutputStream stream) 压缩一个Bitmap对象根据相关的编码、画质保存到一个OutputStream中。其中第一个压缩格式目前有JPG和PNG void copyPixelsFromBuffer(Buffer src) 从一个Buffer缓冲区复制位图像素 void copyPixelsToBuffer(Buffer dst) 将当前位图像素内容复制到一个Buffer缓冲区 我们看到创建位图对象createBitmap包含了6种方法在目前的Android 2.1 SDK中,当然他们使用的是API Level均为1,所以说从Android 1.0 SDK开始就支持了,所以大家可以放心使用。
Android UI开发专题(一) 之界面设计 发帖日期:2010-02-09 10:49:28 标签:ophone 近期很多网友对Android用户界面的设计表示很感兴趣,对于Android UI开发自绘控件和游戏制作而言掌握好绘图基础是必不可少的。本次专题分10节来讲述,有关OpenGL ES相关的可能将放到以后再透露。本次主要涉及以下四个包的相关内容: android.content.res 资源类 android.graphics 底层图形类 android.view 显示类 android.widget 控件类 一、android.content.res.Resources 对于Android平台的资源类android.content.res.Resources可能很多网友比较陌生,一起来看看SDK上是怎么介绍的吧,Contains classes for accessing application resources, such as raw asset files, colors, drawables, media or other other files in the package, plus important device configuration details (orientation, input types, etc.) that affect how the application may behave.平时用到的二进制源文件raw、颜色colors、图形drawables和多媒体文件media的相关资源均通过该类来管理。 int getColor(int id) 对应res/values/colors.xml Drawable getDrawable(int id) 对应res/drawable/ XmlResourceParser getLayout(int id) 对应res/layout/ String getString(int id) 和CharSequence getText(int id) 对应 res/values/strings.xml InputStream openRawResource(int id) 对应res/raw/ void parseBundleExtra (String tagName, AttributeSet attrs, Bundle outBundle) 对应res/xml/ String[] getStringArray(int id) res/values/arrays.xml float getDimension(int id) res/values/dimens.xml 二、android.graphics.Bitmap 作为位图操作类,Bitmap提供了很多实用的方法,常用的我们总结如下: boolean compress(https://www.wendangku.net/doc/7212410544.html,pressFormat format, int quality, OutputStream stream) 压缩一个Bitmap对象根据相关的编码、画质保存到一个OutputStream中。其中第一个压缩格式目前有JPG和PNG void copyPixelsFromBuffer(Buffer src) 从一个Buffer缓冲区复制位图像素
武汉理工大学华夏学院 课程报告 课程名称:智能手机软件开发 题目:基于Android的手机通讯录的设计与实现 专业信息工程系 班级 学号 姓名 成绩 指导教师 2015年3月23日至2015年6月12日
智能手机软件开发大作业 根据所学的Android 手机开发的知识,采用Eclipse、JAVA开发一个基于Android 平台的手机通讯录软件,具体要求如下: 1.要发该软件能够在以上的平台上运行。 2.要求软件界面美观,操作方便,符合日常使用规范。 3.能够通过该手机通讯录来添加新的联系人,用来存放联系人的姓名、单位、电话、QQ、地址等信息。 4.能够通过该手机通讯录来编辑联系人信息,来修改联系人的个人信息。 5.能够通过该手机通讯录来调用系统的通信接口,直接给用户发短信,打电话。 6.在手机通讯录中,添加合适的菜单,来操作手机通讯录。 7.将开发的过程写成报告,要求内容完整,格式规范,条理清晰。
1 设计目的 随着手机通讯录功能的不断加强与完善,手机通讯录对于人们的意义,已不仅仅像记事簿一样显示通讯地址,而是向着个性化、人性化的方向发展移动终端的应用软件和需要的服务将会有很大的发展空间。根据这个特点,设计一个基于Android平台的通讯录系统,能根据手机的特点,存储,管理,修改联系人信息,并且能够根据选定的联系人,对其拨打电话,发送短信等。 手机通讯录作为手机的基本功能之一,每天我们都在频繁地使用着。根据手机功能使用调查显示,通讯录从无到有,从英文到中文,经过了十几年的发展历程,今后的发展趋势就是从通讯录发展为名片夹,也就是在一个人名下,可以存储座机、手机、单位、地址、电子邮件等内容。所以手机通讯录功能越来越齐全,满足了人们的需求。 2 开发环境 由于该android通讯录是一个基于Java语言开发软件,所以选择了作为开发平台,作为插件,它能够安装Android SDK,从而可以安装使用Android虚拟机,使得程序得以开发,亦更为方便。 本通讯录系统就是在+Android平台环境下编写设计而成的。 3 需求分析 该系统针对的主要用户是Android手机用户。Android手机通信管理系统包括以下主要内容: (1) 用户通过联系人功能可以保存联系人的详细信息,可以对联系人进行编辑、删除、拨打电话、发送短信可以根据索引条件搜索联系人。 (2) 用户通过短信记录功能可以发送短信,删除短信记录。
在android开发中,常见的布局方式有:LinearLayout (线性布局),RelativeLayout (相对布局),TableLayout (表格布局),AbsoluteLayout (绝对布局),FrameLayout (帧布局),今天我们主要介绍表格布局的相关属性。 TableLayout经常用到的属性有: android:collapseColumns:以第0行为序,隐藏指定的列: android:collapseColumns该属性为空时,效果如下图: 把android:collapseColumns=0,2--------------》意思是把第0和第2列去掉,如下图: android:shrinkColumns:以第0行为序,自动延伸指定的列填充可用部分: 当LayoutRow里面的控件还没有布满布局时,shrinkColumns不起作用,如下图: 设置了shrinkColumns=0,1,2,布局完全没有改变,因为LayoutRow里面还剩足够的空间。当LayoutRow布满控件时,如下图: 设置设置了shrinkColumns=2,则结果如下图,控件自动向垂直方向填充空间:
android:stretchColumns:以第0行为序,尽量把指定的列填充空白部分: 设置stretchColumns=1,则结果如下图,第1列被尽量填充(Button02与TextView02同时向右填充,直到TextView03被压挤到最后边)。 更多android开发视频入门教程,点此查看>> https://www.wendangku.net/doc/7212410544.html,/course/2/。
实验2 android的界面设计(控件与布局) 学时:4学时 一、实验目的: 1、了解Android编程原理 2、掌握界面控件设计 3、了解和熟悉常用控件的使用、界面布局等内容。 二、实验内容: 1.基本控件的制作: (1)TextView的制作: a)体会Autolink,依次更换属性:web/phone/all/email/ b) 制作跑马灯效果 android:ellipsize 设置当文字过长时,该控件该如何显示。有如下值设置:”start”—-省略号显示在开头;”end”——省略号显示在结尾;”middle”—-省略号显示在中间;”marquee”——以跑马灯的方式显示(动画横向移动) android:marqueeRepeatLimit 在ellipsize 指定marquee 的情况下,设置重复滚动的次数,当设置为marquee_forever 时表示无限次。 android:focusableInTouchMode:是否在触摸模式下获得焦点。 android:focusable 控件是否能够获取焦点 (2)EditView制作 (a) maxLength:最大输入长度属性
(b) singleLine:多行文本框 (c) inputType:限制输入文本类型 (d) hint:设置提示信息 2.布局设计 (1) LinearLayout布局: (2)Relative Layout:
(3)Table Layout 3.建立一个如图所示的图形界面:
4.用ListView制作如图界面(图片自定) (将该题以你的学号命名,发给你班的学习委员,以班为单位统一发给我,我的邮箱为:610083060@https://www.wendangku.net/doc/7212410544.html,): 5.用expandablelistview制作如下界面:
第5讲TableLayout布局与适配器TableLayout 表格布局 类似HTML中的Table,以行列的方式来布局组件,但是没有边框。 它是由多个TableRow对象组成,每个TableRow是一个容器,可以有0个或多个单元格,每向TableRow添加一个组件,就增加一列。 表格布局中,列的宽度由该列中最宽的那个单元格决定 这些TableRow,不能设置layout_width和ayout_hight(设置了也没有用),宽度默认是wrap_content,根据具体的包裹内容来决定显示大小,但是每个单元格中的内容可以设置高度和宽度。 android:collapseColumns="2" 设置被隐藏的列是第?列(从0开始数) android:shrinkColumns="2" 设置被收缩的是第?列 android:stretchColumns="1" 设置被拉伸的是第?列 举例:见教材P56注册界面 部分常用组件用法补充: (1)ToggleButton (开关按钮) 是一个具有选中和未选择状态双状态的按钮,并且需要为不同的状态设置不同的显示文本。默认情况下是未选中textOff,需要在前面加上一个文本标签TextView来说明显示的内容。
1、关于android进程,说法不正确的是( B ) A、组件运行所在的进程,是由androidManifest.xml决定,它可以指定该组件运行于哪个进程。 B、背景进程是不为用户所见的Activity,但是还会有可能被用户看到,所以它不能被杀死 C、当急需内存时,android会决定优先关闭那些空闲的进程 D、可视进程一般不会不被系统所杀死 2、Matrix类的作用( A ) A、可以存储缩小或放大比列 B、存储文件中的图片信息 C、存储资源中的图片信息 D、存储内存中的图片信息 3、关于主题的说法,错误的是( D ) A、它是属性集合 B、它可以在程序中来设置 C、它通常用于一个Activity或所有Activity上 D、它可以用于单个TextView上 4、setOnTouchEvent 设置返回值为true 和 false有何区别?以下说法较准确是( C ) A、没有区别,都能对事件进行监听 B、设置为true时只能在移动时获得一次监听事件,false则可以多次 C、设置为false是,在处理一次监听事件后,系统将抛弃该次事件 D、返回true表示这个消息已经被处理结束,后续的handler不再接收到这个消息 二、开发技术设计与应用能力部分 注:以下程序均是相关程序或小项目的实现代码,根据每个程序或项目的特性,完成程序空缺部分的内容,使其实现。具体程序代码注释省略。 图1 图2 图3 图4 1)电话实现[主界面如图1] 程序描述:完成手机打电话功能。 public class MainActivity extends Activity { protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(https://www.wendangku.net/doc/7212410544.html,yout.activity_main); Button btn_call = (Button)this.findViewById(R.id.btn_call); btn_call.setOnClickListener(new btnCall()); } private class btnCall implements OnClickListener (1) { public void onClick(View v) { // TODO Auto-generated method stub EditText et_number = (EditText) MainActivity.this.findViewById(R.id.et_number); String s_number = et_number.getText().toString().trim(); (2) Intent i_call = new Intent(); i_call.setAction(Intent.ACTION_CALL(3)); i_call.setData(Uri.parse("tel:"+s_number)); startActivity(i_call); (4) } } } 2)动画实现[主界面如图2] 程序描述:手机屏幕触摸后演示动画,假设XML文件已经设置好,id资源为:R.drawable.panda public class MainActivity extends Activity { ImageView iv_action; AnimationDrawable ad_action; protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(https://www.wendangku.net/doc/7212410544.html,yout.activity_main); iv_action = (ImageView)this.findViewById(R.id.iv_action); iv_action.setBackgroundResource(5)(R.drawable.panda); ad_action = (AnimationDrawable) iv_action.getBackground(); } public boolean onTouchEvent(MotionEvent event) { ad_action.start();(6) return super.onTouchEvent(event); } } 3)撕衣服游戏实现 项目描述:划动屏幕时完成撕衣服效果,并产生撕衣服声音(sound.mp3) public class MainActivity extends Activity { ImageView iv_upper; ImageView iv_below;
一、Android设计常识 开始介绍之前先帮大家梳理一下Android常用单位,方便各位亲们更好的掌握并了解Android端设计规范。 1.1 Android常用单位 1.1.1. PPI(pixels per inch):数字影像的解析度,也就是每英寸所拥有的像素数,即像素密度; PPI计算公式:ppi=√(长度像素数2 + 宽度像素数2)/屏幕对角线英寸数1.1.2. DPI(dots per inch):是指印刷上的计量单位,也就是每英寸上能印刷的网点数,我们设计用于显示器的默认为(72像素/英寸)就好了; 1.1.3. 屏幕尺寸(Screen Size):一般我们所说的手机屏幕尺寸,比如3英寸、5.5英寸等,都是指对角线的长度,而不是手机的面积; 1.1.4. 分辨率(Resolution):是指手机屏幕垂直和水平方向上的像素个数,比如分辨率为:720*1280,是指设备水平方向有720个像素点,垂直方向有1280个像素点 1.1.5. px( pixels):像素,不同设备显示效果相同 1.1.6. pt( point):一个标准的长度单位,ios的逻辑单位,1Pt=1/72英寸,用于印刷业,非常简单易用;标注字体大小(72是早期台式机的DPI) 1.1.7. sp(Scaled-independentpixels):放大像素,安卓的字体单位; 1.1.8. Dp(Density-independentpixels):是指设备的独立像素,不同的设备有不同的显示效果,它与设备硬件有关系; sp和dp基本一样,是android开发里特有的单位,都是为了保证文字在不同密度的显示屏上显示相同的效果;dp与设备硬件有关,与屏幕密度无关,sp与屏幕密度和设备硬件均无关;
竭诚为您提供优质文档/双击可除listview实现漂亮的自定义表格实例 篇一:android学习笔记二十四之listView列表视图二 android学习笔记二十四之listView列 表视图二 前面一篇我们介绍了常用的几种适配器的简单实现和listView的简单使用,这一篇中,我们介绍一下listView 的优化和一些其它的问题。 listView优化方法一 在listView中,我们最常用的就是自定义adapter,在我们自定义adapter中,需要实现两个比较重要的方法getcount()和getView(),前者是负责计算listView的 总item数,后者是生成item,有多少个item就会调用getView()方法多少次。getView()方法每次调用的时候都会重新inflate一个View出来返回去,但是对于listView,只需要保留能够显示的最大的View的数目即可,而新的View 可以复用消失的View。listView给我们提供了可复用的View 对象,在getView()方法里面,有一个参数View,这个就是可以复用的View对象。当参数View为null的时候,我
们需要inflate一个View,当它不为null的时候,我们可以直接将他返回。例如: @override publicViewgetView(inti,Viewview,Viewgroupviewgroup) { Viewholderviewholder; //view为空的时候,inflate一个新的view if(view==null){ view=layoutinflater.from(context).inflate(https://www.wendangku.net/doc/7212410544.html,yout. item_base_adapter,null);viewholder=newViewholder(); https://www.wendangku.net/doc/7212410544.html,_base_adapter=(textView)view.findViewb yid(https://www.wendangku.net/doc/7212410544.html,_base_adapter);view.settag(viewholder); }else{ viewholder=(Viewholder)view.gettag(); } https://www.wendangku.net/doc/7212410544.html,_base_adapter.settext(datas[i]); //不为空,复用view returnview; }