|
|
楼主 |
发表于 2004-5-10 11:50:04
|
显示全部楼层
深入应用MIDP函数类型
作者：王森 本文选自：开放系统世界—赛迪网 2003年04月10日
不管多么花俏的平台，都是用几个最简单的功能慢慢架构出来的。因此要全盘了解任何一个平台的程序设计技巧，首先一定要了解最底层的函数库。本文将深入探讨MIDP所提供的函数类型，这些函数也是Java手机程序设计的基础。
系统参数的撷取
MIDlet在运作时，必须通过java.lang.System. getProperty()函数来取得系统属性。这些系统属性可以让MIDlet了解它们深处的环境相关信息。它们分别是:
1. microedition.profiles:取得系统所支持的所有Profile信息;
2. microedition.configuration:取得系统所支持的Configuration信息;
3. microedition.locale:取得系统目前所使用的地区信息;
4. microedition.plarform:MIDlet所在平台(或机器)的名称或型号;
5. microedition.encoding:取得系统默认使用的语言编码信息。
字符串与基本类型的转换
MIDlet在运作时，可以透过MIDlet.getAppProperty()函数来取得清单文件或描述文件之中属性的属性值，取得之后都视为字符串。如果需要做一些数学运算，就必须先把字符串转换成数值才行。
要把字符串转换成数值，必须依靠定义在java.lang之中的Byte、Short、Integer、Long四个类型之中的parseXXX()方法。这四个类型都是整型，只有范围上的不同。如果我们截取的字符串，转换成数值之后超过该类型所能负担的范围，就会产生异常情况。
由于CLDC 1.0并不支持浮点数，所以并没有对应浮点数的类型，只有整数类型。但是从CLDC 1.1之后开始支持浮点数，所以CLDC 1.1之后新增Float和Double两个类型。
我们还可以利用java.lang.Character来判断某个字符是否为数字、英文字母大小写，也可以利用此类别转换英文字母的大小写。
执行时间的测量
当MIDlet运作时，随时都可以利用System. currentTimeMillis()取得目前时间与1970年1月1日零时 UTC时间(协调世界时)的差距，传回值为Long类型，而且以毫秒来表示。程序任何两个地方调用System. currentTimeMillis()之后，将所得的结果相减，就是所经过的毫秒数。范例TimeMeasureTest.java如下:
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
public class TimeMeasureTest extends MIDlet
{
public TimeMeasureTest()
{
}
public void startApp()
{
long start = System.currentTimeMillis() ;
//随便做一些事情
for(int i=0 ; i <1000000 ; i++) ;
long end = System.currentTimeMillis() ;
System.out.println("Pass " + (end-start) + " Milliseconds") ;
}
public void pauseApp()
{
}
public void destroyApp(boolean unconditional)
{
}
}
执行结果:
Pass 234 Milliseconds
日期处理
在java.util中，Calendar、Date、TimeZone是三个用来处理与日期相关功能的类型。下面将介绍它们的用法。
TimeZone类型所代表的是时区，全球的统一时间称作UTC。也就是说，在全世界任何时间点上，时间的表示都一样。根据每个地区所在的位置不同，又制定了时区的概念。这些时区如表1所示，详细的时区表请参见http://linux.ccidnet.com期刊浏览2003年第4期。
表1 时区表
时区与 UTC 的偏移量 (+1:00代表往描述
后一个小时，-1:00代表往前一
个小时，与一般标准表示法相反)
NZDT+13:00 新西兰白昼时间（夏时制）
IDLE+12:00 国际日期变更线，东边
NZST+12:00 新西兰标准时间
NZT+12:00 新西兰时间
AESST+11:00 澳大利亚东部标准夏时制
ACSST+10:30 中澳大利亚标准夏时制
NT-11:00 州时间（Nome Time）
IDLW-12:00 国际日期变更线，西边
............ ......
格林威治时间(GMT)与UTC是没有时间差的。其它时区都会和GMT或UTC有个时间差。所以如果以时区来分的话，每个时区相同的时间有可能是不同的UTC。
TimeZone无法用new来产生，只能通过TimeZone.getDefault()取得系统默认使用的时区，或使用TimeZone.getTimeZone(id)指定要使用的时区来产生。产生之后，就可以利用某个TimeZone类型的实体调用getID()方法来取得所使用的时区。useDaylightTime()可以得知是否使用日光节约时间，getRawOffset()可以得知此TimeZone使用的时区和GMT相差多少。
TimeZone有个静态方法叫做getAvailableIDs()，可以取得系统所有支持的时区。除非特殊目的，否则一般请用TimeZone.getDefault()取得系统默认使用的时区。
Date类别负责记录与1970年1月1日零时UTC时间的差距，一般可以使用“Date date = new Date(time) ;”来产生，time就是与1970年1月1日零时UTC时间的差距，以毫秒来计。如果使用“Date date = new Date();”来产生Date类别，就如同调用了“Date date = new Date(System.currentTimeMillis());”，也就是Date会封装new时的时间。
Date类型本身除了以毫秒存放与1970年1月1日零时 UTC时间的差距外，本身没有其它功能了。要从Date类型解译出正确的年、月、日、星期几、几点、几分、几秒的信息，就必须依靠Calendar类别才行。Calendar无法用new产生，只能通过Calendar.getInstance()取得使用系统默认时区与地区所建立的Calendar，或使用Calendar. getInstance(TimeZone tz)指定要使用的时区来产生Calendar。所以调用Calendar.getInstance()，实际上等同于调用Calendar.getInstance(TimeZone.getDefault())。
有了Calendar的实体之后，就可以利用其setTime()生成一个Date对象的实体，或是setTimeMillis()生成一个long类型的数值来设定Calendar的内容。范例CalendarTest.java如下:
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import java.util.*;
public class CalendarTest extends MIDlet
{
public CalendarTest()
{
}
public void startApp()
{
Calendar cal = Calendar.getInstance() ;
Date now = new Date() ;
cal.setTime(now) ;
System.out.println(cal) ;
}
public void pauseApp()
{
}
public void destroyApp(boolean unconditional)
{
}
}
执行结果:
Sun, 10 Nov 2002 10:04:19 UTC
Calendar、Date与TimeZone类型将来都可以和LCDUI函数库之中的DateField类型紧密配合。除了直接将Calendar对象的实体打印出来之外，还可以利用set与get方法来设定或取得部分信息。
Timer与TimerTask的使用
java.util套件之中有两个类型与工作排程非常有关系，它们分别是Timer与TimerTask。其中，Timer是一个定时器，可以设定成特定时间或特定时间周期产生信号。不过，只有Timer是没有用的，必须配合TimerTask才起作用。Timer一旦与某个TimerTask产生关联，就会在产生信号的同时连带执行TimerTask所定义的工作。
TimerTask的制作非常容易，任何一个类型只要继承TimerTask类型，并调用其run()方法即可。run()方法就是自行定义的工作。一旦Timer在特定时间或特定时间周期产生信号，run()方法就会被执行。我们会透过Timer的schedule()方法来设定特定时间或特定时间周期，并将它与某个TimerTask联系(进行TimerTask的排程)。最后，可以使用Timer的cancel()方法来停止Timer。调用cancel()之后，Timer就会和TimerTask脱离关系。TimerTask本身也有cancel()方法。
在特定时间产生信号
假设希望在3秒之后执行某些工作，范例程序MyTask1.java如下:
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import java.util.*;
public class MyTask1 extends TimerTask
{
public void run()
{
//打印出run()被调用的时间
System.out.println("Task1 Fire Time:") ;
System.out.println(System.currentTimeMillis());
}
}
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import java.util.*;
public class TimerTest1 extends MIDlet
{
public TimerTest1()
{
}
public void startApp()
{
Timer timer = new Timer() ;
//规定3000毫秒之后(3秒)激活MyTask1
timer.schedule(new MyTask1(),3000);
//显示出排程后的时间
System.out.println("Task Schedule Time:") ;
System.out.println(System.currentTimeMillis());
}
public void pauseApp()
{
}
public void destroyApp(boolean unconditional)
{
}
}
执行结果如下:
Task Schedule Time:
1036932682671
Task1 Fire Time:
1036932685671
执行时，屏幕上会先显示出：
Task Schedule Time:
1036932682671
大约3秒钟之后才会显示出：
Task1 Fire Time:
1036932685671
我们可以发现两者的时间差距为3000毫秒。
Timer的schedule()方法除了可以给定一个Long类型外，也可以给定一个Date类型的实体。如果希望从现在起5秒之后执行某些工作，范例程序MyTask2.java如下:
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import java.util.*;
public class MyTask2 extends TimerTask
{
public void run()
{
System.out.println("Task2 Fire Time:") ;
System.out.println(System.currentTimeMillis());
}
}
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import java.util.*;
public class TimerTest2 extends MIDlet
{
public TimerTest2()
{
}
public void startApp()
{
Timer timer = new Timer() ;
Date after5sec = new Date(System.currentTimeMillis()+5000) ;
timer.schedule(new MyTask2(),after5sec);
System.out.println("Task Schedule Time:") ;
System.out.println(System.currentTimeMillis());
}
public void pauseApp()
{
}
public void destroyApp(boolean unconditional)
{
}
}
执行结果如下:
Task Schedule Time:
1036933242234
Task2 Fire Time:
1036933247250
执行时，屏幕上会先显示出：
Task Schedule Time:
1036933242234
大约5秒钟之后才会显示出：
Task2 Fire Time:
1036933247250
我们可以发现两者的时间差距大约为5000毫秒。之所以无法确定差距是5000毫秒，是因为在排程(呼叫timer.schedule(new MyTask2(),after5sec))之前，系统必须先取得目前时间，再产生Date对象，这些动作都会造成些许的时间差。
在特定时间周期产生信号
上述两个范例都是设定在某个特定时间产生信号，接下来将示范如何在某个特定的时间周期产生信号。假设希望在5秒钟之后，每隔4秒中产生信号，范例程序MyTask3.java如下：
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import java.util.*;
public class MyTask3 extends TimerTask
{
long lasttime ;
public void run()
{
long now = System.currentTimeMillis();
System.out.print("Task3 Fire Time: ") ;
System.out.print(now);
System.out.print(" ; Intervel :") ;
//
System.out.println(now-lasttime);
//
lasttime = now ;
}
}
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import java.util.*;
public class TimerTest3 extends MIDlet
{
Timer timer ;
public TimerTest3()
{
}
public void startApp()
{
Form f = new Form("Test") ;
Display.getDisplay(this).setCurrent(f) ;
timer = new Timer() ;
//Date after5sec = new Date(System.currentTimeMillis()+5000) ;
MyTask3 mt = new MyTask3() ;
mt.lasttime = System.currentTimeMillis() ;
//timer.schedule(mt,after5sec,4000);
timer.schedule(mt,5000,4000);
System.out.println("Task Schedule Time:") ;
System.out.println(System.currentTimeMillis());
}
public void pauseApp()
{
}
public void destroyApp(boolean unconditional)
{
timer.cancel() ;
}
}
执行结果如下:
Task Schedule Time:
1036934383453
Task3 Fire Time: 1036934388453 ; Intervel :5000
Task3 Fire Time: 1036934392453 ; Intervel :4000
Task3 Fire Time: 1036934396453 ; Intervel :4000
Task3 Fire Time: 1036934400453 ; Intervel :4000
Task3 Fire Time: 1036934404453 ; Intervel :4000
....
从范例MyTask3.java中可以看出，第一个信号出现在5秒之后，以后的信号都是每隔4秒产生一次。周期性产生信号所使用的sechdule()方法，其第二个参数可以是Long型或Date型。
在MyTask3.java之中，我们使用“long now = System.currentTimeMillis();”来抓取run()一开始执行时的时间。如果任何时候想知道这一次run()的激活时间，可以随时调用TimerTask的scheduledExecutionTime()方法。所以上述取得开始时间的方式可以用“long now = scheduledExecutionTime();”来取代，而MyTask3.java可以改成下面方式:
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import java.util.*;
public class MyTask3 extends TimerTask
{
long lasttime ;
public void run()
{
System.out.print("Task3 Fire Time: ") ;
long now = scheduledExecutionTime() ;
System.out.print(now);
System.out.print(" ; Intervel :") ;
System.out.println(now-lasttime);
lasttime = now ;
}
}
由于scheduledExecutionTime()方法只传回这次run()的起始时间，所以在任何地方呼叫都不会影响到时间精确度。更重要的一点，如果scheduledExecutionTime()和System.currentTimeMillis()都可以达到目的时，使用scheduledExecutionTime()不会浪费系统资源。
另外要注意的是，当不希望Timer再产生信号时，可以使用Timer的cancel()方法来停止Timer。调用cancel()之后，Timer就会和TimerTask脱离关系，而且不再产生任何信号，此时TimerTask才能重新被排程。Timer属于系统资源，每次MIDlet离开之前，都应该使用Timer的cancel()方法来停止Timer。TimerTask本身也有cancel()方法，如果TimerTask被安排在特定的时间周期内执行，那么调用TimerTask的cancel()方法之后，也可以保证以后其工作都不会再被执行。
信号精确度
最后，我们要讨论的是信号精确度的问题。前面的范例中，TimerTask里只做简单的计算。由于简单的计算花的时间不多，所以都可以在下次重新产生信号前完成。可是，如果run()里的工作无法在下次产生信号前完成呢?举例来说，我们希望每4秒钟产生一次信号，但是run()方法有时却需要5.5秒完成工作，有时2.2秒就完成了。有关范例MyTask4.java如下:
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import java.util.*;
public class MyTask4 extends TimerTask
{
long lasttime ;
public void run()
{
long now = System.currentTimeMillis();
System.out.print("Task4 Fire Time: ") ;
System.out.print(now);
System.out.print(" ; Intervel :") ;
System.out.println(now-lasttime);
lasttime = now ;
doSomething() ;
}
public void doSomething()
{
//用随机数来仿真工作所需时间,有时超过4000毫秒,有时少于4000毫秒
try
{
Random rdm = new Random() ;
int i = rdm.nextInt()%2 ;
if(i==0)
{
Thread.sleep(2500) ;
System.out.println("doSomething : 2500 millisecond");
}else
{
Thread.sleep(5500) ;
System.out.println("doSomething : 5500 millisecond");
}
}catch(Exception e){}
}
}
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import java.util.*;
public class TimerTest4 extends MIDlet
{Timer timer ;
public TimerTest4()
{}
public void startApp()
{
Form f = new Form("Test") ;
Display.getDisplay(this).setCurrent(f) ;
timer = new Timer() ;
//Date after5sec = new Date(System.currentTimeMillis()+5000) ;
MyTask4 mt = new MyTask4() ;
mt.lasttime = System.currentTimeMillis() ;
//timer.schedule(mt,after5sec,4000);
timer.schedule(mt,5000,4000);
System.out.println("Task Schedule Time:") ;
System.out.println(System.currentTimeMillis());
}
public void pauseApp()
{}
public void destroyApp(boolean unconditional)
{
timer.cancel() ;
}
}
执行结果如下:
Task Schedule Time:
1036936893265
Task4 Fire Time: 1036936898265 ; Intervel :5000
doSomething : 5500 millisecond
Task4 Fire Time: 1036936903765 ; Intervel :5500
doSomething : 2500 millisecond
Task4 Fire Time: 1036936907765 ; Intervel :4000
doSomething : 2500 millisecond
Task4 Fire Time: 1036936911765 ; Intervel :4000
doSomething : 5500 millisecond
Task4 Fire Time: 1036936917265 ; Intervel :5500
doSomething : 5500 millisecond
Task4 Fire Time: 1036936922765 ; Intervel :5500
doSomething : 2500 millisecond
Task4 Fire Time: 1036936926765 ; Intervel :4000
doSomething : 5500 millisecond
从这个范例可以看出，schedule()方法的运行属于一种称为fixed-delay execution的模式。也就是说，如果run()在时间周期之内完成，那么下一次的信号就会在下一次预定的时间产生。但是，如果run()无法在时间周期之内完成，那么下一次的信号就延迟，而且上一个run执行之后就会立刻产生信号。所以，会有上述的结果。
另外一个可以在固定周期产生信号的方法为scheduleAtFixedRate()，但是其特性和schedule()不太相同。有关范例TimerTest5.java请参见http://linux.ccidnet.com期刊浏览2003年第4期(TimerTask的部分仍采用MyTask4)。
从范例TimerTest5.java中可以看出，scheduleAtFixedRate()方法的运行属于一种称为fixed-rate execution的模式。也就是说，如果run()在时间周期之内完成，那么下一次的信号就会在下一次预定的时间产生。但是，如果run()无法在时间周期之内完成，那么等到run完成之后，下一次的信号产生就尽量赶上原本应该产生信号的时间。以上面的例子来说，第二次的讯号应该在第一次产生信号4000毫秒之后产生，可是却因为上一次的执行使得必需延迟1500毫秒。同样，第三次信号应该在第一次产生信号8000毫秒之后产生，可是由于第二次的run()延迟1500毫秒才完成，所以总计就比预计时间延迟了3000毫秒。而第三次所需工作时间只要2500毫秒。完成第三次run()之后，系统必须要尽快赶上原本预计的时间。所以立刻产生信号，使得第四次与第三次之间的时间差只有2500毫秒，此时就赶上了1500毫秒。第四次所需工作时间只要2500毫秒，因此完成第四次run()之后，系统必须要尽快赶上原本预计的时间，所以立刻产生信号，使得第五次与第四次之间的时间差只有2500毫秒，此时又赶上了1500毫秒。到目前为止，已经把落后的时间都追回来了，这就是尽量赶上的意思。即使第五次的工作只花了2500毫秒就完成，但是由于没有落后的进度需要追赶，所以和第六次的时间相差就是预计的4000毫秒。 |
|
IP卡
狗仔卡
发表于 2004-5-10 11:36:35
提升卡
置顶卡
沉默卡
喧嚣卡
变色卡
显身卡