十一月's profileNOVEMBREBlogListsGuestbookMore  |  Tools Help |
|
|
April 28 使用platformRequest()自动更新MIDlet套件MIDP 2.0提供了一系列的新特性，其中一个就是调用平台的应用。例如可以调用WAP浏览器访问特定的网址，也可以调用电话应用程序呼叫某个号码。上述两个功能都可以使用MIDlet类的platformRequest()方法实现，platformRequest()接受一个String类型的参数url，如果是呼叫电话号码则url的形式为tel:13810011001。如果是调用WAP浏览器则url的形式类似于http://www.j2medev.com/wap.wml。 本文介绍如何使用platformRequest()方法自动更新MIDlet套件，在MIDP的文档中说明。如果url的形式为一个指定的MIDlet套件，可以是JAD文件，也可以是jar文件。例如http://www.j2medev.com/helloworld.jad。这个时候，此请求会被认为是安装MIDlet套件来对待，这样用户可以控制安装的过程，就像我们直接从WAP浏览器输入地址安装MIDlet套件一样。如果请求的MIDlet套件是当前正在运行的应用程序的升级版，则当前的程序需要先退出，然后执行更新操作。 如果想让发布的MIDlet套件具备自动升级的功能，那么需要提供一个服务器端程序，服务器端程序能够检测是不是有更新版本的应用程序下载，并且可以将这个结果告诉给客户端。通常这样的服务器端可以实现为Web应用程序，用servlet和MIDlet通信。当用户运行MIDlet的时候，MIDlet首先连接指定的服务器获取信息，如果没有新版软件则正常运行，如果有新版本的软件则是用platformRequest（）方法请求安装应用程序。 if (update == NEED_UPDATE) { try { platformRequest("http://www.j2medev.com/wap/autoupdate.jar"); destroyApp(true); notifyDestroyed(); } catch (ConnectionNotFoundException ex) { ex.printStackTrace(); }
}else{ //do something else } 这里我们在代码中执行destroyApp(true)，让MIDlet套件主动退出。如果想做的更为专业，可以在检测到有新版本的软件的时候，显示一个对话框让用户选择是否自动更新，根据用户的选择执行相关的操作。下面的代码UpdateMIDlet可以用于演示此项功能。 /** * author mingjava * Created on 2006-3-8 */ package com.j2medev.autoupdate;
import java.util.Random; import javax.microedition.io.ConnectionNotFoundException; import javax.microedition.lcdui.Display; import javax.microedition.lcdui.Form; import javax.microedition.midlet.MIDlet; import javax.microedition.midlet.MIDletStateChangeException;
public class UpdateMIDlet extends MIDlet {
public static int NEED_UPDATE = 0;
public static int NO_UPDATE = 1;
private Display display = null;
protected void startApp() throws MIDletStateChangeException { if (display == null) { display = Display.getDisplay(this); int update = (new Random().nextInt() >>> 1) % 2; if (update == NEED_UPDATE) { try { platformRequest("http://www.j2medev.com/wap/autoupdate.jar"); destroyApp(true); notifyDestroyed(); } catch (ConnectionNotFoundException ex) { ex.printStackTrace(); }
}else if(update == NO_UPDATE){ Form form = new Form("Test"); form.append("No update is needed"); display.setCurrent(form); } } }
protected void pauseApp() {
}
protected void destroyApp(boolean arg0) throws MIDletStateChangeException {
}
} 为了模拟是否有升级软件的可能，我们在startApp()中随机生成一个随机数update。如果update等于0则代表有升级版本，如果update等于1则代表不需要升级。为了简单起见，这里我们没有编写联网检测升级版本的程序。此程序在Nokia 7610上测试通过，可以自动升级MIDlet套件。 April 24 Eclipse及其插件介绍和下载一：Eclipse及其插件介绍和下载 0.Eclipse下载 二： After installing Eclipse 3 and Tomcat Plugin,the plugin is not loaded! Lanching Eclipse 3 with "-clean" option can fix this problem. Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=540513 Eclips使用秘技(绝对经典)
Eclipse下J2ME开发环境的配置Java~J2ME安装文件说明：
jdk1.5.4.exe-------------------------------Java运行环境安装文件 配置eclipse 1． 安装jdk1.5.4.exe（安装在任何目录都可），同时配置Java环境（可以不配置，配置后可以使用JDK工具包内 工具） 2． 安装j2me_wireless_toolkit-2_2-ml-windows.exe （WTK模拟器），按顺序解压两个更新包到所装目录上 3． 解压proguard3.7.zip到某个目录下 4． 解压eclipsesdk_win32.zip（绿色程序）到一个目录，不要这时就打开eclipse，先解压eclipse汉化包，到 该目录下，否则会导致只有部分内容被汉化 5． 运行eclipse，配置自己学习的工作路径，选择 帮助—>软件更新—>查找并安装—>搜索要安装的新功能部件 6． 选择 新建已归档的站点,选择eclipseme.feature_1.6.0_site.zip文件,安装,重启eclipse 7． 选择 首选项—>J2ME—>Device Management—>Import 在Specify search directory下,选择你所装的WTK模 拟器的目录 8． 选择 Refresh ，后按完成，使用DefaultColorPhone为默认模式，这时已为eclipse配置上了模拟器 9． 再到 “首选项”找到，J2ME—>Packaging—>obfuscation，在Proguard Root Directory右边的框中，选择 刚才解压的proguard3.7的文件夹，应用，这时为eclipse配置上了混淆器 10． 再到 “首选项”找到，Java—>调试，将“发生未不捕获到的异常时暂挂执行”与“在发生编译错误时暂挂 执行”这两个选项调为“未选中”状态，再把下面的调试器超时（毫秒）的右侧数值设置为15000 11． 配置完毕 使用eclipse进行开发控制台程序 1． 新建 Java项目，填写项目名，完成 2． 新建 类，填写名称，选中public static void main(String[] args) 完成 3． 在填写代码区，System.out.print(“hello”); 4． 在快捷键找到“运行”，选择“Java应用程序”，按“新建启动配置”（或双击Java应用程序），为该程序 新建一个启动的配置，填写Main类 5． 这时在JAVA应用下，出现“新建配置”，运行 6． 在代码输入区下方的控制台标签下，显示”hello”，完成程序
1． 新建 J2ME下的J2ME Midlet Suite，填写项目名，下一步，完成 2． 新建 J2ME下的J2ME Midlet，填写名称，完成 3． 点击运行，新建一个Wireless Toolkit Emulator的运行配置，运行，出现手机样式，运行成功
1． 运行“开始”－“所有程序”－“J2ME Wireless Toolkit 2.2”－“KToolbar”程序 2． 新建项目，填写项目名字，和MIDlet类名（必须为继承MIDlet的那个类的名字），确定 3． 到该程序目录下的apps目录中，找到你所建立的项目目录，把程序文件放在src目录下，然后返回KToolbar界 面，选择运行，显示手机样式，运行成功
改为指向SDK(即JDK 的安装目录) April 18 J2ME游戏优化秘密本文章描述了代码优化在为移动设备写运行起来速度快的游戏中扮演的角色。我会用例子说明如何、什么时候和为什么要优化你的代 码，来榨干兼容MIDP的手机的每一滴性能。我们将要讨论为什么优化是必要的和为什么有时候最好不要优化。我将解释高级优化和低 级优化的差别，然后我们会知道如何使用J2ME无线开发包（WTK）自带的Profile程序来发现到哪里去优化你的代码。这篇文章最后揭 示了很多让你的MIDlet运行的技术。 为什么优化? 计算机游戏可以分为两大类: 实时的和输入驱动的. 输入驱动的游戏显示游戏的当前运行状态,并在继续之前无限地等待用户的输入. 扑克牌游戏属于这一类，同样，大多数的猜谜游戏、过关游戏和文字冒险游戏都属于这一类。实时游戏，有时候被称为技能或动作游戏 ，不等待用户，他们不停地运行直到游戏结束。 技能和动作游戏经常以大量的屏幕上运东为特征(想想Galaga游戏和Robotron游戏)。刷新率必须至少有10fps（每秒的帧数）并且要 有足够的动作来保持玩家的挑战性。它们需要玩家快速的反应和好的手眼配合，所以就强迫S&A（技能和动作）游戏必须对玩家的输入 有很强的响应能力。在快速响应玩家案件的同时提供高帧数的图形动作，这是实时游戏的代码必须运行起来快的原因。在用J2ME开发 的时候，挑战性就更大了。 Java 2 Micro Edition（J2ME）是java的一个分解版本。 适用于有限功能的小型设备，比如手机和PDA。J2ME设备有： *有限的输入能力（没有键盘!）（译者注：这里键盘特指个人电脑的键盘） *小的显示尺寸 *有限的内存容量和堆大小 *慢速的CPU 在J2ME平台上写出快的游戏-------写出在比桌面电脑里的慢得多的CPU上运行的代码更是挑战了开发者。 什么时候不优化 如果你不是在写一个技能或者动作游戏，那么可能不需要优化。如果玩家已经为自己的下一步考虑了几秒钟抑或几分钟，她可能不会 介意如果你的游戏响应花掉了几百微秒。这个规则的一个例外是，如果这个游戏在决定下一步如何运行的时候有大量的工作要处理，比 如搜索一百万个可能的象棋片组合。这种情况下，你可能想要优化你的代码，从而在几秒钟内计算出电脑的下一步，而不是几分钟。 就算你正在写这种类型的游戏，优化也可能是危险的。许多这样的技术伴随着一个代价--他们表示着好”的程序设计这个通常概念飞 过来的时候，同时使你的代码更难读懂。有些是一个权衡，需要开发者大大增加程序的大小来得到性能上一点点的改进。J2ME开发者 们对于保持他们的JAR尽可能的小这个挑战再熟悉不过了。这里是一些不优化的理由： *优化是一个增加bug的好手 *有些技术会降低你的代码的移植性 *你可能要花费大量的努力来得到微小的或者没有改进 *优化是困难的 最后一点需要一些阐述。优化是一个活动目标，在Java平台上更是这样，而且在J2ME上就更加突出，因为其运行环境是那样的多变。 你优化后的代码可能在一个模拟器上运行得更快，但却在实际设备上更慢，或者相反。为一部手机优化可能会降低其在另一部上的性能 。 不过还是有希望。有两条路径你可以做优化，高层的和底层的。第一条基本上会在所有的平台上增加执行性能，甚至会改进你代码的 整个质量。第二条是可能会让你头疼的，但是那些底层技术是很容易创造的，而且更加容易消去如果你不想使用它们。最起码，他们看 起来很有趣。 我们将用系统的timer在实际设备上剖析你的代码，这可以帮助你测量出那些技术在你所开发的硬件上到底有多有效。 最后一点： *优化是有趣的 一个反面例子： 让我们来看一看这个包含两个类的简单的应用程序，首先，是Midlet... import javax.microedition.midlet.*; import javax.microedition.lcdui.*; public class OptimizeMe extends MIDlet implements CommandListener { private static final boolean debug = false; private Display display; private OCanvas oCanvas; private Form form; private StringItem timeItem = new StringItem( "Time: ", "Unknown" ); private StringItem resultItem = new StringItem( "Result: ", "No results" ); private Command cmdStart = new Command( "Start", Command.SCREEN, 1 ); private Command cmdExit = new Command( "Exit", Command.EXIT, 2 ); public boolean running = true; public OptimizeMe() { display = Display.getDisplay(this); form = new Form( "Optimize" ); form.append( timeItem ); form.append( resultItem ); form.addCommand( cmdStart ); form.addCommand( cmdExit ); form.setCommandListener( this ); oCanvas = new OCanvas( this ); } public void startApp() throws MIDletStateChangeException { running = true; display.setCurrent( form ); } public void pauseApp() { running = false; } public void exitCanvas(int status) { debug( "exitCanvas - status = " + status ); switch (status) { case OCanvas.USER_EXIT: timeItem.setText( "Aborted" ); resultItem.setText( "Unknown" ); break; case OCanvas.EXIT_DONE: timeItem.setText( oCanvas.elapsed+"ms" ); resultItem.setText( String.valueOf( oCanvas.result ) ); break; } display.setCurrent( form ); } public void destroyApp(boolean unconditional) throws MIDletStateChangeException { oCanvas = null; display.setCurrent ( null ); display = null; } public void commandAction(Command c, Displayable d) { if ( c == cmdExit ) { oCanvas = null; display.setCurrent ( null ); display = null; notifyDestroyed(); } else { running = true; display.setCurrent( oCanvas ); oCanvas.start(); } } public static final void debug( String s ) { if (debug) System.out.println( s ); } } Second, the OCanvas class that does most of the work in this example... import javax.microedition.midlet.*; import javax.microedition.lcdui.*; import java.util.Random; public class OCanvas extends Canvas implements Runnable { public static final int USER_EXIT = 1; public static final int EXIT_DONE = 2; public static final int LOOP_COUNT = 100; public static final int DRAW_COUNT = 16; public static final int NUMBER_COUNT = 64; public static final int DIVISOR_COUNT = 8; public static final int WAIT_TIME = 50; public static final int COLOR_BG = 0x00FFFFFF; public static final int COLOR_FG = 0x00000000; public long elapsed = 0l; public int exitStatus; public int result; private Thread animationThread; private OptimizeMe midlet; private boolean finished; private long started; private long frameStarted; private long frameTime; private int[] numbers; private int loopCounter; private Random random = new Random( System.currentTimeMillis() ); public OCanvas( OptimizeMe _o ) { midlet = _o; numbers = new int[ NUMBER_COUNT ]; for ( int i = 0 ; i < numbers.length ; i++ ) { numbers[i] = i+1; } } public synchronized void start() { started = frameStarted = System.currentTimeMillis(); loopCounter = result = 0; finished = false; exitStatus = EXIT_DONE; animationThread = new Thread( this ); animationThread.start(); } public void run() { Thread currentThread = Thread.currentThread(); try { while ( animationThread == currentThread && midlet.running && !finished ) { frameTime = System.currentTimeMillis() - frameStarted; frameStarted = System.currentTimeMillis(); result += work( numbers ); repaint(); synchronized(this) { wait( WAIT_TIME ); } loopCounter++; finished = ( loopCounter > LOOP_COUNT ); } } catch ( InterruptedException ie ) { OptimizeMe.debug( "interrupted" ); } elapsed = System.currentTimeMillis() - started; midlet.exitCanvas( exitStatus ); } public void paint(Graphics g) { g.setColor( COLOR_BG ); g.fillRect( 0, 0, getWidth(), getHeight() ); g.setColor( COLOR_FG ); g.setFont( Font.getFont( Font.FACE_PROPORTIONAL, Font.STYLE_BOLD | Font.STYLE_ITALIC, Font.SIZE_SMALL ) ); for ( int i = 0 ; i < DRAW_COUNT ; i ++ ) { g.drawString( frameTime + " ms per frame", getRandom( getWidth() ), getRandom( getHeight() ), Graphics.TOP | Graphics.HCENTER ); } } private int divisor; private int r; public synchronized int work( int[] n ) { r = 0; for ( int j = 0 ; j < DIVISOR_COUNT ; j++ ) { for ( int i = 0 ; i < n.length ; i++ ) { divisor = getDivisor(j); r += workMore( n, i, divisor ); } } return r; } private int a; public synchronized int getDivisor( int n ) { if ( n == 0 ) return 1; a = 1; for ( int i = 0 ; i < n ; i++ ) { a *= 2; } return a; } public synchronized int workMore( int[] n, int _i, int _d ) { return n[_i] * n[_i] / _d + n[_i]; } public void keyReleased(int keyCode) { if ( System.currentTimeMillis() - started > 1000l ) { exitStatus = USER_EXIT; midlet.running = false; } } private int getRandom( int bound ) { // return a random, positive integer less than bound return Math.abs( random.nextInt() % bound ); } } 这个程序是一个模拟一个简单游戏循环的MIDlet： *work 执行 *draw 绘制 *poll for user input 等待用户输入 *repeat 重复 对于快速游戏，这个循环一定要尽可能的紧凑和快速。我们的循环持续一个有限的次数（LOOP_COUNT=100）,并且用系统timer来计 算整个作业花费了多少毫秒，我们就可以测量并改善它的性能。时间和执行的结果会显示在一个简单的窗口上。用Start命令来开启测 试。按任意键会提前退出循环，退出按钮用来结束程序。- 在大多数游戏里面，主游戏循环中的作业会更新整个游戏状态-----移动所有的角色，检测并处理冲突，更新分数，等等。在这个例 子里面，我们并没有做什么特别有用的事。程序仅仅是在一个数组之间做一些算数运算，然后 把这些结果加起来。 run（）函数计算了每次循环所花费的时间。每一帧，OCanvas.paint（）方法都在屏幕上的16个随机的地方显示这个数。一般的， 你可以用这个方法在你的游戏里面画出你的图像元素，我们的代码在该过程中作了一些有用的摹写。 不管这些代码看起来有多么的无意义，它给了我们足够的机会去优化它的性能。 ******************第二页 哪里去优化 -- 90/10规则 在苛求性能的游戏里面，有90%的时间是在执行其中%10的代码。我们的优化努力就应该针对这10%的代码。我们用一个Profier来定位 这 10%. 要运行J2ME无线开发包中的profier工具,选择edit菜单下的preferences选项. 这将会显示preferences窗口.选择 Monitoring这一栏,将"Enable Profiling"悬赏，然后点ok按钮。什么也没有出现。这是对的，在Profier窗口显示之前，我们需要 在模拟器中运行我们的程序然后退出。现在就做. 图1显示了如何打开Profiler工具。 我的模拟器（运行在Windows XP下，Inter P4 2.4GHz的CPU）报告我100次这个循环用了6,407毫秒，或者说6又1/2秒。这个程序报 告说62或者63毫秒每帧。在硬件(一个 motorola的i85s)上运行会慢得多。 一帧的时间大约是500毫秒，整个循环用了52460毫秒。 在本文这一课中，我们将试着改善这个数据。 当你退出这个程序时，profiler窗口就会出现，然后你会看见一个文件夹浏览器中有一些东西，在左边的面板上会有一个熟悉的树形 部件。方法间的联系会在这个结构列表中显示。每一个文件夹是一个方法，打开一个文件夹会显示它所调用过的方法。在该树中选择一 个方法会显示那个方法的profiling信息并在右边的面板显示所有被它调用过的方法。注意在每一个元素旁边显示了一个百分数。这就 是该方法在整个执行过程中所占的执行时间的百分比。我们必须翻遍这棵树，来寻找时间都到哪里去了，并对占用百分比最高的方法进 行优化，如果可能的话。 图2 -- Profiler程序调用的图 对这个profiler，有几点需要说明。首先你的百分比多半会和我的不一样，但是他们的比例会比较相似--总是在最大的数之后。我的 数据在被次运行的时候都会改变。为了保持情况一致，你可能希望关掉所有的后台程序，像Email客户端，并在你测试的时候保持你正 在进行的任务最少。还有，不要在用profiler之前混淆（obfuscate）你的代码，不然你的方法会被神秘的标示为b或者a或者ff。最 后profiler不会因为你运行模拟器的设备的差别而改变，它和硬件是完全独立的。 打开最高百分比的那个文件夹，我们看到有66.8%的时间在执行一个被称为 "com.sun.kvem.midp.lcdui.EmulEventHandler$EventLoop.run"的方法，这个对我们并没有什么帮助。用类似的方法，再往下寻 找更深层次的方法，持续下去，你就会找到一个大的百分比停留在serviceRepaints()上,最后到了我们的 OCanvas.paint()方法.另 外有30%的时间在OCanvas.run()方法里.这两个方法都在我们的主程序循环中,这并不奇怪.我们不会在我们的MIDlet类中花任何时间 做优化,同样地我们不会对游戏的主循环外的任何代码做优化. 在我们的例子程序中的百分比的划分在真实的游戏中并不是完全的没有特性. 你多半会在一个真实的视觉游戏中发现这个大的执行时 间的比例是在paint()方法中. 相比于非图形化程序,图形化程序总是要花很长的时间. 不幸的是,我们的图形程序已经被写在了J2ME API这一层下,对于改善它们的性能,我们没有多少可以做的.我们可以做的是在用哪个和如何用它们之间做出聪明的决定. 高级vs低级优化 我们在该文章随后的地方会看到一些低级代码优化的技术.你会看见它们很容易被嵌入到现有代码中,并且在改善性能的同时相应的降 低其可读性. 在我们使用那些技术之前,最好还是继续在我们的代码和算法的设计上下功夫.这是高级优化. Michael Abrash,"Quake"的一位开发者,一次写道,"the best optimizer is between your ears"(最好的游戏器就在你的两耳之 间).这有不只一种方法而且如果如果实现花更多的时间来思考正确的做事的方式,你会得到极大的回报. 使用正确的算法所带来的性能 提升,会比用低级优化技术在普通算法上作优化得到的提升大很多. 你用低级技术可能会得到几点百分比的提升,但是请首先从最上层 开始并且使用你的大脑(你可以在你的两耳之间找到它). 现在让我们来看一看我们在paint()方法中作了什么.每次在屏幕上打印消息"n ms per frame"时,我们调用了 Graphics.drawString() 16次. 我们不知道drawString的任何内部作业,但是我们知道它用掉了大量时间,所以让我们试试其它的方 式.让我们直接将这个字符串画到一个图片实例上, 然后再画16次这个图片. public void paint(Graphics g) { g.setColor( COLOR_BG ); g.fillRect( 0, 0, getWidth(), getHeight() ); Font font = Font.getFont( Font.FACE_PROPORTIONAL, Font.STYLE_BOLD | Font.STYLE_ITALIC, Font.SIZE_SMALL ); String msMessage = frameTime + "ms per frame"; Image stringImage = Image.createImage( font.stringWidth( msMessage ), font.getBaselinePosition() ); Graphics imageGraphics = stringImage.getGraphics(); imageGraphics.setColor( COLOR_BG ); imageGraphics.fillRect( 0, 0, stringImage.getWidth(), stringImage.getHeight() ); imageGraphics.setColor( COLOR_FG ); imageGraphics.setFont( font ); imageGraphics.drawString( msMessage, 0, 0, Graphics.TOP | Graphics.LEFT ); for ( int i = 0 ; i < DRAW_COUNT ; i ++ ) { g.drawImage( stringImage, getRandom( getWidth() ), getRandom( getHeight() ), Graphics.VCENTER | Graphics.HCENTER ); } } 当我们运行这个版本的软件时,我们看到我们的paint()方法占用的时间百分比减少了一点点.往里看,我们看到drawString()方法只被 调用了101次,而且现在是敌人啊我Image方法执的次数最多，被调用了1616次。虽然我们做了更多的工作，，但是程序运行得快了一点 ，因为我们所用的graphics调用要快一点。 你或许发现了吧一个字符串画到一个图片上会影响显示，因为J2MEbing不支持图片的透明，所以大量的背景被重写了。这是一个 weruhe优化可能导致你重新审核程序需求的例子。如果你真的需要与文字重合，你可能被迫要用更少的时间来处理。 这个代码或许好了一点点，但是它仍然有很大的可改进空间。让我们来看一看我们的第一个低级优化技术。 第三页 循环之外？ 循环多少次，在for()内部的代码就会执行多少次。要改善性能，那么，我们想要尽可能的把循环中的代码移动到循环外。我们可以在 profiler中看到paint()被调用了101次，并且在它之中的循环又循环了16次。在这两个循环中有哪些我们可以移出来呢？让我们从他 们的定义说明开始，每当调用paint()时,我们声明了一个字体，一个字符串，一个图片对象和一个图形对象.我们将要把它们移出到该 类的最前面. public static final Font font = Font.getFont( Font.FACE_PROPORTIONAL, Font.STYLE_BOLD | Font.STYLE_ITALIC, Font.SIZE_SMALL); public static final int graphicAnchor = Graphics.VCENTER | Graphics.HCENTER; public static final int textAnchor = Graphics.TOP | Graphics.LEFT; private static final String MESSAGE = " ms per frame"; private String msMessage = "000" + MESSAGE; private Image stringImage; private Graphics imageGraphics; private long oldFrameTime; 你会发现,我把Font对象变成了一个公共的常量.这一点在你的程序中通常是有用的,你可以把你所要用到的字体声明都集中到一个地方 .我发现anchor也一样,所以我也把文本和图像坐标放到了一起.对这些的预处理,保持了这些运算--虽然不怎么重要--在循环之外了. 我把MESSAGE也变成了一个常量.那是因为Java喜欢到处创建字符串对象.字符串如果没有被控制,它们可能导致大量的内存消耗.不要 把它们留给自动回收,否则你很可能会遇到内存泄露,那最终会影响你的程序性能,特别是当垃圾回收器被调用得过于频繁时.字符串创 造垃圾,而垃圾不好.用一个字符串常量减少了这类问题.稍后我们会看到如何运用一个StringBuffer来完全的阻止字符串滥用带来的 内存流失. 既然我们把那些变成了实例变量,我们需要在构造函数里面添加这些代码: stringImage = Image.createImage( font.stringWidth( msMessage ), font.getBaselinePosition() ); imageGraphics = stringImage.getGraphics(); imageGraphics.setFont( font ); 另一个很酷的对于图形对象的大写字符的事是,我们可以设置一次字体然后就可以忘掉它了,不用每次在循环中都设置一次. 每次我们 还需要用fillRect()擦去图片对象. 热情的编码者可能会发现这里有一个机会从同一个图片创建两个图形对象,然后为fillRect()的 调用预设其中一个的颜色为COLOR_BG,并为 drawString()的调用预设另一个的颜色为COLOR_FG.不幸地,对同一个图片的多次调用 getGraphics()没有被定义,在不同的平台上不一样,于是你的技巧可能在Motorola上有效但在NOKIA上不行.如果不确定,就不做. 还有另一种改进我们的paint()的方法.再次使用我们的大脑我们认识到,如果从上次调用以来frameTime的值改变了,那么我们只需要 重画这个字符串.那是我们的新变量oldFrameTime到来的地方,下面是新的方法: public void paint(Graphics g) { g.setColor( COLOR_BG ); g.fillRect( 0, 0, getWidth(), getHeight() ); if ( frameTime != oldFrameTime ) { msMessage = frameTime + MESSAGE; imageGraphics.setColor( COLOR_BG ); imageGraphics.fillRect( 0, 0, stringImage.getWidth(), stringImage.getHeight() ); imageGraphics.setColor( COLOR_FG ); imageGraphics.drawString( msMessage, 0, 0, textAnchor ); } for ( int i = 0 ; i < DRAW_COUNT ; i ++ ) { g.drawImage( stringImage, getRandom( getWidth() ), getRandom( getHeight() ), graphicAnchor ); } oldFrameTime = frameTime; } 现在Profiler显示OCanvas的paint总共所花费的时间百分比已经降低为42.01%了.对比结果frameTime在 paint()中的调用,对 drawString()和fillRect()的调用次数已经从101变为69了.那时一个不错的节约,没有多少可以做的了,现在是该认真的时候了.你优 化得越多,它就变得越困难.现在我们要去挖掉最后几块循环中的代码.我们现在正在剃去非常小的百分比或者说百分比的碎片了,但是 我们比较幸运,他们加起来还是比较可观的. 让我们从一些简单的开始.让我们调用那些函数一次并且把结果暂存在循环之外,而不是每次都调用getHeight()和getWidth(). 下一 步,我们将停止使用字符串并手动使用StringBuffer来做所有事.依靠在Graphics.setClip()的调用中限制绘画区域,我们将剃掉一些 对drawImage()的调用.最后,我们将避免在循环中对java.util.Random.nextInt()的调用. 这是些新的变量... private static final String MESSAGE = "ms per frame:"; private int iw, ih, dw, dh; private StringBuffer stringBuffer; private int messageLength; private int stringLength; private char[] stringChars; private static final int RANDOMCOUNT = 256; private int[] randomNumbersX = new int[RANDOMCOUNT]; private int[] randomNumbersY = new int[RANDOMCOUNT]; private int ri; ...这里是我们构造函数里的新代码: iw = stringImage.getWidth(); ih = stringImage.getHeight(); dw = getWidth(); dh = getHeight(); for ( int i = 0 ; i < RANDOMCOUNT ; i++ ) { randomNumbersX[i] = getRandom( dw ); randomNumbersY[i] = getRandom( dh ); } ri = 0; stringBuffer = new StringBuffer( MESSAGE+"000" ); messageLength = MESSAGE.length(); stringLength = stringBuffer.length(); stringChars = new char[stringLength]; stringBuffer.getChars( 0, stringLength, stringChars, 0 ); 你现在可以看到我们在预处理显示(Display)和图片(Image).我们也在暂存512次getRandom()的调用的结果,有了StringBuffer也不 再需要msMessage这个字符串.当然,肉依然在paint()方法中: public void paint(Graphics g) { g.setColor( COLOR_BG ); g.fillRect( 0, 0, dw, dh ); if ( frameTime != oldFrameTime ) { stringBuffer.delete( messageLength, stringLength ); stringBuffer.append( (int)frameTime ); stringLength = stringBuffer.length(); stringBuffer.getChars( messageLength, stringLength, stringChars, messageLength ); iw = font.charsWidth( stringChars, 0, stringLength ); imageGraphics.setColor( COLOR_BG ); imageGraphics.fillRect( 0, 0, iw, ih ); imageGraphics.setColor( COLOR_FG ); imageGraphics.drawChars( stringChars, 0, stringLength, 0, 0, textAnchor ); } for ( int i = 0 ; i < DRAW_COUNT ; i ++ ) { g.setClip( randomNumbersX[ri], randomNumbersY[ri], iw, ih ); g.drawImage( stringImage, randomNumbersX[ri], randomNumbersY[ri], textAnchor ); ri = (ri+1) % RANDOMCOUNT; } oldFrameTime = frameTime; } 我们现在正在用一个StringBuffer来写我们的消息中的字符.相比于在开头插入一个字符,在StringBuffer的后面添加要容易得多,所 以我把字符显示的顺序调换了,现在frameTime在消息的最后了,比如:"ms per frame:120".我们每次重写最后的几位frameTime字符 ,保持消息的一部分不变. 像这样明白的运用StringBuffer会节约paint()方法内系统从创建到销毁字符串的时间.它是额外的工作,但 值得做.注意,我在把 frameTimer强制转换为一个整数.我发现用append(long) 导致了一个内存泄露.我不知道为什么,但这是一个为 什么你需要用软件注意事情的例子. 我们用font.charsWidth()来计算消息图片的宽度,以让我们可以画得最少.我们使用均衡字符,来使"ms per frame:1"的宽度比这绘 制它图片小,我们用Graphics.setClip(),所以我们就不需要画更多的. 这同样意味着我们只需要填充一个足够遮掩我们需要的区域那 么大的一个矩形.我们希望绘图省下的时间比调用font.charWidth()花去的时间多. 在这里这可能不会带来多大区别,但它确实是一个绘制玩家的分数到屏幕上的不错的技术.那种情况下,在绘制0分和150,000,000分之 间有着巨大的差别. 这多少是因为font.getBaselinePosition()的不正确的返回值,这个值好像和font.getHeight()的返回值一样, 啊! (叹气) 最后,我们刚刚搞定了我们的两个数组中预先计算的"随机"数,这节约了我们产生随机数的一些调用.注意用取模运算来实现一个循环数 组的用法.注意我们用同一个TextAnchor绘制图片和字符串,所以现在setClip()工作正常. 我们已经在一个灰色地带，怀着对这个版本的代码产生的数据。Profiler高速我们这个代码比没有这些改变的代码在paint()方法里 多花了大概7%多一点的时间。对font.charsWidth()的调用可能是个原因，它占了4.6%。（这并不多，但它可以被减少。注意我们每 次都会获取 MESSAGE字符串的宽度。我们可以简单的在循环体之间计算它，并简单的把它加到frameTime的宽度上。）同样，新的对 setClip()的调用被标识为0.85%，而且看起来大大的增加了drawImage所占用的时间百分比（从27.58%到33.94%）。 到这一点了，看起来所有额外的代码肯定会使执行慢下来，但是程序产生的书记和这个假设矛盾了。在模拟器上的数据上下波动，看起 来好像没有长时间的测试，是不能下决定了，但是我的i85s报告说额外的代码比不加要快一点点，在没有对setClip()或者 charsWidth()时数据是 37130毫秒，而两个都有的时候是36540。我做了我的耐心所能忍受的那么多次，结果都一致。这使执行环境 差异这一点的影响突出起来。一旦你到了一个你不能确定会不会有进展的地方，你可能会被迫继续所有在硬件上的测试，这需要大量的 对JAR文件的安装和卸载。 看起来我们已经从我们的图形程序段压榨出了大量的性能。现在是对我们的work()方法进行同样的高级和低级优化的时候了。让我们 来回顾一下那个方法： public synchronized int work( int[] n ) { r = 0; for ( int j = 0 ; j < DIVISOR_COUNT ; j++ ) { for ( int i = 0 ; i < n.length ; i++ ) { divisor = getDivisor(j); r += workMore( n, i, divisor ); } } return r; } 每次在run()中的循环，我们都传递一个数组参数。在work()中的循环外计算了我们的除数，然后调用workMore()来做这个除法。这 里所有事都错了，你可能也发现了。因为一开始，程序员已经把getDivisor()的调用放到了循环内。如果j的值在循环内部没有改变， 那么除数是不变的，真的属于内循环外面。 但是让我们多想一想，这个调用本身就是完全不必要的。下面的代码做了同样的事情... public synchronized int work( int[] n ) { r = 0; divisor = 1; for ( int j = 0 ; j < DIVISOR_COUNT ; j++ ) { for ( int i = 0 ; i < n.length ; i++ ) { r += workMore( n, i, divisor ); } divisor *= 2; } return r; } ...没有对getDivisor()的调用。现在我们的profiler告诉我们run()方法花了23.72%的时间，对应于我们做这些改进以前的38.78% 。请总是在使用低级优化技术之前首先使用你的大脑来优化。接下来，让我们看一看它们中的一些技术。 第四页 低级优化 所有的程序员都对子程序和函数---为了避免在多个地方重复，把程序中共用的代码从应用程序中提出来--的概念很熟悉。不幸地，这 个通常的 “好”变成习惯会影响性能，因为方法的调用会带来一定量的开销。最简单的减少对一个方法的调用所耗费的时间的方法是 ，仔细地挑选他们的声明修饰语。我们的程序员已经很小心了，已经把他的work()和workMore()方法同步了，以防万一其它的线程同 时调用了它们。这很不错，但是如果我们对性能很看重，我们常常要做出一些牺牲，今天我们的牺牲是安全的。 好了，我们知道不会有其它人会调用这些方法，那么我们可以不怎么担心地把他们同步起来。还有什么其它的可以做？让我们来看一看 这个方法类型的列表： *synchronized 该方法是最慢的，因为需要获取一个对象锁 *interface 该方法是次慢的 *instance 这个方法居中 *final 该方法比较快 *static 该方法是最快的 所以我们不应该让所有的都是synchronized，而且看起来我们甚至可以把work()和workMore标示为final static方法。这样做会减 少1%模拟器中run()方法所花的时间。 另一个影响方法调用性能的因素是，传递给该方法的参数的个数。我们调用了workMore()51712次，每次都传递一个整形数组和两个 整形变量给这个参数并返回一个整形变量。在这个有点微不足道的例子中，可以很容易地把workMore()方法拆散到work()的方法体中 来完全地避免这个调用。在真实世界中，这是个很难的决定，特别是当这意味着需要把代码复制到你程序周围的时候。在profiler上 测试一下来看和没做这一步之前到底有多大的差别。如果你不能把所有的方法去掉，试着减少你传递的参数的个数。参数越多，开销就 越大。 public final static int work( int[] n ) { divisor = 1; r = 0; for ( int j = 0 ; j < DIVISOR_COUNT ; j++ ) { for ( int i = 0 ; i < n.length ; i++ ) { r += n[i] * n[i] / divisor + n[i]; } divisor *= 2; } return r; } 哇哦！去掉workMore()的调用把run中的时间开销砍到了9.96%。现在开始，一路上都会上升。让我们来看一看两个最基本的优化技术 ---降低强度（strength reduction）和解开循环。 降低强度就是将一个慢一点的操作用一个相对快一点的完成同样的工作的去替换。最普通的就是使用位移运算符，它和对2的乘除运算 是相等的。比如说，x>>2和x/4是相等的（2的2次幂），x<<10和x*1024是相等的（2的10次幂）。一个令人惊讶的巧合，我们的除数 总是2的幂方（是不是很幸运！），所以我们可以用位移来替换那些除法。 解开循环减少了代码控制流的开销，但在循环中做更多的操作，少执行几次循环，或者完全把循环去掉。由于我们的DIVISOR—— COUNT只是8，解开我们的循环变得简单起来。 public final static int work( int[] n ) { r = 0; for ( int i = 0 ; i < n.length ; i++ ) { r += n[i] * n[i] + n[i]; } for ( int i = 0 ; i < n.length ; i++ ) { r += (n[i] * n[i] >> 1) + n[i]; } for ( int i = 0 ; i < n.length ; i++ ) { r += (n[i] * n[i] >> 2) + n[i]; } for ( int i = 0 ; i < n.length ; i++ ) { r += (n[i] * n[i] >> 3) + n[i]; } for ( int i = 0 ; i < n.length ; i++ ) { r += (n[i] * n[i] >> 4) + n[i]; } for ( int i = 0 ; i < n.length ; i++ ) { r += (n[i] * n[i] >> 5) + n[i]; } for ( int i = 0 ; i < n.length ; i++ ) { r += (n[i] * n[i] >> 6) + n[i]; } for ( int i = 0 ; i < n.length ; i++ ) { r += (n[i] * n[i] >> 7) + n[i]; } return r; } 有两个重点，第一，你会发现解开我们的循环需要我们复制一些代码。这是你在J2ME中想要的最后一件事，程序员们总是在与JAR作战 ，但要记得 JARing（打包）过程包括了压缩，而压缩工作对重复的代码最有效，所以上面的代码可能不会像你所想的那样对你的jar 文件大小产生大的影响。再者，这都是代价交换。你的代码可以很小，很快，易读，任意选择其中的两个。第二点是位移操作符合乘除 运算的优先级不一样，所以你常常需要在表达式周围放置括号，而乘除运算符则不需要。 解开循环和使用位移操作符提升了1%多一点，不算坏。现在让我们把注意力集中到数组访问上。数组在C中是快速的数据结构，但因为 那个原因他们也很危险---如果你的代码访问了超过数组尾部的地址，那么你就重写了你不应该访问的内存区域，而且结果通常都是可 怕的。 相比之下，java是一个很安全的语言---像那样执行到数组尾部以外会简单地抛出一个 ArrayIndexOutOfBoundsException(一个数组 地址越界异常)。每次访问数组的时候系统都检查数组的下标是否有效，这使得数组的访问比C中要慢。再者，对于java内部对于数组 的处理我们没有什么可以做的，但是我们可以在它周围作一些聪明的决定。在上面的代码中，举例来说，我们访问了n[i]24次。我们 可以通过把n[i]的值存储于一个变量来省略掉很多那样的数组访问。稍微高级一点的想法同样揭示了我们可以用聪明的多的方式重新 安排他们，像这样... private static int divisor; private static int r; private static int ni; public final static int work( int[] n ) { r = 0; for ( int i = 0 ; i < n.length ; i++ ) { ni = n[i]; r += ni * ni + ni; r += (ni * ni >> 1) + ni; r += (ni * ni >> 2) + ni; r += (ni * ni >> 3) + ni; r += (ni * ni >> 4) + ni; r += (ni * ni >> 5) + ni; r += (ni * ni >> 6) + ni; r += (ni * ni >> 7) + ni; } return r; } ...把run()中耗费的时间减少到了6.18%，一点也不坏。在我们继续之前，让我多说一点关于数组的事。一个稍微高级的优化（也就是 “thought”）可能揭示了数组可能不是这里必要的正确的数据结构。想想一个链表或者一些其他的结构，如果他们将提升性能。第二 点，如果你将要使用一个数组而且也需要复制它的内容到另一个数组，请总是使用System.arraycopy()。完成同样的工作，它会比自 己写的函数要快一点。最后，数组的性能比java.util.Vector对象的性能要好一点。如果你需要一种Vectors提供的功能，想想自己 写代码并测试一下，确保你的代码要快一点。 好了，我们真的把优化的事情做完了。我们刚刚介绍了暂存数组变量和该变量的平房的另一对变量。你可能在想为什么那些变量在方法 体的声明之外就被声明了。他们在循环外是因为每次定义一个整形数都有一点开销，而且我们需要保持他们在循环外也有效，对么？错 ！ 什么都不假设，我们确实为整形变量的声明节约了时间，但是如果那些变量在方法内部的定义为局部的，代码实际上可能会更慢。这是 因为局部变量表现得更好，因为JVM解释一个在方法外声明的变量会花更长的时间。所以让我们把他们变为局部变量。 最后，我们可以微微改变一下for()循环。计算机处理和零比较比处理和其他的非零数比较要快。那意味着我们可以改变我们的循环的 顺序并像这样重写方法，我们就可以和零比较： public final static int work( int[] n ) { int r = 0; int ni; int nis; int i; for ( i = n.length ; --i >= 0 ; ) { ni = n[i]; nis = ni * ni; r += nis + ni; r += (nis >> 1) + ni; r += (nis >> 2) + ni; r += (nis >> 3) + ni; r += (nis >> 4) + ni; r += (nis >> 5) + ni; r += (nis >> 6) + ni; r += (nis >> 7) + ni; } return r; } 就是它了！这个代码可能会快一点，但是 profiler的结果不是那么的明显，清楚地是这个方法变得难懂了。或许这里还有更多可改进 的空间，但是让我们再看一下paint()方法，看看我们所学的里面有没有什么在这儿可以介绍的。 记住我们所学的关于局部变量的么？如果你被迫要用一个实例变量，而且你在一个方法中引用了那个变量多次，它可能值得你创建一个 局部变量来让 JVM只处理那个引用一次。你将引入一个声明和一个赋值，这会让程序变慢，但根据经验，如果一个变量被引用了超过 两次，我们将会使用这个技术。 我们同样可以在我们的paint()方法中运用降低强度，用一个循环移位计数器来代替取模运算符。这只有在我们的随机数暂存数组的长 度是2的倍数（令人惊讶地）的时候是可能的。最后，我们可以把我们的比较运算改成总是和零比较。这里是新的改进过的paint()方 法： public void paint(Graphics g) { StringBuffer sb = stringBuffer; Graphics ig = imageGraphics; char[] sc = stringChars; int sl; int ml = messageLength; int ril = ri; int iw = 0; g.setColor( COLOR_BG ); g.fillRect( 0, 0, dw, dh ); if ( frameTime - oldFrameTime != 0 ) { sb.delete( ml, stringLength ); sb.append( (int)frameTime ); sl = stringLength = sb.length(); sb.getChars( ml, sl, sc, ml ); iw = font.charsWidth( sc, 0, sl ); ig.setColor( COLOR_BG ); ig.fillRect( 0, 0, iw, ih ); ig.setColor( COLOR_FG ); ig.drawChars( sc, 0, sl, 0, 0, textAnchor ); } for ( int i = DRAW_COUNT ; --i >=0 ; ) { g.setClip( randomNumbersX[ril], randomNumbersY[ril], iw, ih ); g.drawImage( stringImage, randomNumbersX[ril], randomNumbersY[ril], textAnchor ); ril++; ril &= 255; } ri = ril; oldFrameTime = frameTime; } 此外，怀着对profiler结果的敬意，我们已经在路的尽头了。这些改变并不影响图形函数被调用的次数，所以最好情况下这个差别也 会很小。但是当我们把所有对我们的work()方法的改变组合起来并且装在新的JAR到设备上时，这个差别是很大的。我的motorola i85s现在在14030毫秒内完成了测试----快了两倍多！ 这个代码还有最后一点需要改变。我把它放到最后是因为它没有书写得特别好，并且我的经验是它的表现在不同的实现间不一样。看着 OCanvas中的start()和run()方法，你可以看到我已经用了一个单独的动画线程。这是Java中处理动画的传统方法。在游戏中用这个 技术的一个问题是，每当重复循环时，我们被迫等待系统事件，比如说按键或者一个命令被传输了。毕竟我们在一个同步块中调用 wait()方法等待。这是艰辛的优化代码。毕竟我们的困难工作优化了其他所有事情，但我们在最激烈的时候实际上什么正确的事情也 没能做。更坏的是，为WAIT_TIME得到一个好的数据并不简单。如果我们 wait()太长，游戏就变慢了。如果我们没有wait()足够的时 间,按键可能被错过然后游戏停止了对用户输入的响应。 J2ME提供了一个这个问题的解决方案，用Display.callSerially()方法。API声明callSerially (Runnable r)"导致了在repaint 周期完成不久之后，为了和事件流同步，Runnable对象r让其run()被推迟调用“[原文是："causes the Runnable object r to have its run() method called later, serialized with the event stream, soon after completion of the repaint cycle"]。通过使用callSerially()，我们可以完全的取消对wait()的调用。系统会保证我们的work()和paint()方法和用户输入程 序同步地被调用，那样游戏就会保持可响应性。这里是一些新的方法... public void start() { started = frameStarted = System.currentTimeMillis(); loopCounter = result = 0; finished = false; exitStatus = EXIT_DONE; run(); } public void run() { frameTime = System.currentTimeMillis() - frameStarted; frameStarted = System.currentTimeMillis(); if ( midlet.running && !finished ) { result += work( numbers ); repaint(); display.callSerially(this); loopCounter++; finished = ( loopCounter > LOOP_COUNT ); } else { elapsed = System.currentTimeMillis() - started; midlet.exitCanvas( exitStatus ); } } ...此外我们还需要声明并得到一个Display的句柄： Display display = Display.getDisplay( midlet ); 没有了对wait()的调用，现在我的i85s在10180毫秒内完成了代码的运行---差不多省了40%。你可能希望更大的性能提升，在得知我 们刚刚消除了100次50毫秒的对wait()的调用，但是请记住这个技术也是关于用户输入响应的。 再次，让我强调一下这个动画方法需要小心使用。在使他在NOKIA上工作的时候我遇到的麻烦，而且他们所有的示例代码（即使是游戏 代码）都使用了wait()技术。即使是在Motorola上，我在动画Canvas上添加了命令对象的时候，使用callSerially()的时候也遇到 了问题。在你在家尝试这个之前请小心测试。 第五页 其他的技术 一个我不能在我的示例程序中包含的技术是，最佳的使用switch()。Switch非常普遍的用于实现有限状态自动机（Finite State Machines），在为非玩家角色的行为控制做人工智能的代码时。在你使用switch的时候，像这样写代码是一个好的编程习惯： public static final int STATE_RUNNING = 1000; public static final int STATE_JUMPING = 2000; public static final int STATE_SHOOTING = 3000; switch ( n ) { case STATE_RUNNING: doRun(); case STATE_JUMPING: doJump(); case STATE_SHOOTING: doShoot(); } 这没有什么不对的，这些变量很不错而且离得很远，万一我们想要加一个在RUNNING和JUMPING之间的变量，像 STATE_DUCKING = 2500。但是显然switch选项可以被编译为一个两字节的代码，如果所用的整数紧靠在一起那么这个两字节的代码会更快，所以这会更 好： public static final int STATE_RUNNING = 1; public static final int STATE_JUMPING = 2; public static final int STATE_SHOOTING = 3; 在使用定点数学库（Fixed Point math library）的时候，有一些优化你可以做。首先，如果你除了一个相同的数很多次，你应该计 算出那个数的倒数然后把运算改变为执行一个乘法。乘法要比除法快一点。所以不是... int fpP = FP.Div( fpX, fpD ); int fpQ = FP.Div( fpY, fpD ); int fpR = FP.Div( fpZ, fpD ); ...你应该把它重新写成这样： int fpID = FP.Div( 1, fpD ); int fpP = FP.Mul( fpX, fpID ); int fpQ = FP.Mul( fpY, fpID ); int fpR = FP.Mul( fpZ, fpID ); 如果你在每一帧要做数百次的除法，这会有所帮助。第二点，不要默认你的FP数学函数库不错。don't take your FP math library for granted. 如果你有它的源代码，打开它然后看一下里面发生了什么。保证所有的方法都被声明为final static并看看有没有机 会优化它的代码。比如，你可能发现这个乘法方法需要把int强制转换为long然后再转换回来： public static final int Mul (int x, int y) { long z = (long) x * (long) y; return ((int) (z >> 16)); } 那些转换要花时间。冲突检测使用边界圆球或者半球（bounding circles or spheres）包括将int的平方相加。那会产生一些大的 可能会溢出你的int数据类型的最大值的数字。要避免这个，你可以写下自己的返回一个long型数的平方函数： public static final long Sqr (int x) { long z = (long) x; z *= z; return (z >> 16); } 这个优化的方法避免了两个转换。如果你要做大量的定点计算，你可能要考虑把所有的主游戏循环中的调用替换为long型的。那会节 约大量的方法调用和参数传递。你可能也发现当这个计算被手动写出的时候，你可以减少类型转换所需要的次数。如果你嵌套一些对你 的库的调用，这是尤其正确的。比如： int fpA = FP.Mul( FP.toInt(5), FP.Mul( FP.Div( 1 / fpB ), FP.Mul( FP.Div( fpC, fpD ), FP.toInt( 13 ) ) ) ); 花一些时间Take the time来拆开这些像这样的嵌套调用，然后看你是否能减少类型转换的次数。另一个方式是避免到long类型的转 换，如果你知道涉及到的数字足够小以至于他们肯定不会导致溢出。 在高级优化上，你应该看一些游戏设计上的文章。大量的已知的游戏设计中问题，比如3D几何和碰撞检测已经被非常优雅和有效地解 决了。如果你找不到java源代码，你很可能会找到C源代码或者伪代码来转换。例如，边界检查是一个普通的技术，我们已经在paint ()方法中用到了。我们只需要清除帧到帧之间所改变的那部分屏幕，而不是每次都把整个屏幕清除。因为图形程序相对来说较慢，你 会发现这额外的管理的代价---需要明了屏幕上哪些部分需要被清除--值得付出。 一些手机制造商提供了一些私有的API来帮助程序员们处理一些J2ME表现出来的的限制，比如声音的欠缺，图片透明度的欠缺，等等。 例如， Motorola提供了一个浮点数学库来在芯片上做浮点运算。这个库比最快的定点数学库快很多，精度也高很多。使用这个函数会 完全破坏你代码的可移植性，当然，如果在许多不同的手机上运行不是关键，他们是一个可选项。 结论 *只优化需要的代码 *只在有价值的地方优化 *用profiler来找要优化的地方 *在具体的设备上profiler无能为力，在硬件上使用System timer *在于用低级技术之前，总是先研究你的代码并且试着改进算法 *绘图是慢的，所以尽量节俭地使用图形调用 *在可以减少绘制区域的地方使用setClip() *尽可能的把东西放到循环之外 *拼命地预先计算和暂存 *字符串带来垃圾，垃圾不好，所以使用StringBuffers来代替 *什么都不假设 *可能就使用static final方法，避免synchronized修饰符 *传递尽可能少的参数到经常调用的方法 *如果可能，完全地去掉函数调用 *解开循环 *对2的幂的乘除运算用位移运算代替 *你可以使用位运算符代替取模运算来实现循环 *试着用零来代替和其他数的比较 *数组访问比C要慢，所以暂存数组元素 *消去公共的子表达式 *局部变量要比引用变量快 *如果可以callSerially()就不要wait() *在switch()中使用小的变量作选项 *检查定点数学库并且优化它 *拆开嵌套的FP调用来减少类型转换 *除法比乘法慢，所以用乘于倒数来代替除法 *用使用过和测试过的算法 *为了保护可移植性，小心地使用私有高性能API 下一步去哪里？ 优化是魔法。任何的计算机的心脏都是CPU，java的心脏在虚拟CPU，JVM（java虚拟机）。要榨干虚拟机的每点性能，你需要了解大 量的表层以下的事情是如何工作的。特别地，你需要知道哪些事情JVM可以做得快，哪些慢。寻找有java里层工作的可靠信息的网站。 你不必要学习如何按字节来写程序，但是你懂得越多，就越容易跟上优化你的程序性能的新方式。 没有什么能够代替经验。你会及时地发现关于J2ME的性能特性和所开发的手机的你个人的秘密。即使你不能编出有独特特性的代码， 你可以用它设计你的下一个游戏。在开发我的游戏的时候，我发现调用5次drawImage()来分别绘制5个有25像素的图片要比调用它一 次来绘制一个五倍大小的图片慢得多。这个只是肯定会帮助我设计我的下一个游戏。 祝你好运，玩得开心！ 资源： 1. J2ME's official web site contains the latest on what's happening on this front. 2. Like wireless games? Read the Wireless Gaming Review. 3. Discuss J2ME Game Development at j2me.org 4. A great site on many aspects of Java Optimization 5. Another great site on Optimization 6. Many articles on J2ME performance tuning 7. The amazing Graphics Programming Black Book by Michael Abrash 8. The Art of Computer Game Design by Chris Crawford 关于作者： Mike Shivas has been playing video games since before the advent of the 8-bit home microcomputer. He has been programming in Java since 1996, has consulted for MasterCard on wireless solutions and is the published author of several J2ME video games. Readers may contact Mike at mailto:mshivas@hotmail.com?subject=FastCode. j2me实现图片透明效果 （转）代码 /** * * @author Jagie * */ public class ShadowMIDlet extends MIDlet { Canvas c = new ShadowCanvas(); public ShadowMIDlet() { } protected void startApp() throws MIDletStateChangeException { Display.getDisplay(this).setCurrent(c); } protected void pauseApp() { // TODO Auto-generated method stub } protected void destroyApp(boolean arg0) throws MIDletStateChangeException { // TODO Auto-generated method stub } } /** * * @author Jagie * */ class ShadowCanvas extends Canvas implements Runnable { int w, h; // 原始图片 Image srcImage; // 原始图片的像素数组 int[] srcRgbImage; // 渐变图片的像素数组 int[] shadowRgbImage; int imgWidth, imgHeight; int count; public ShadowCanvas() { w = this.getWidth(); h = this.getHeight(); try { srcImage = Image.createImage("/av.png"); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } imgWidth = srcImage.getWidth(); imgHeight = srcImage.getHeight(); // 制造原始图片的像素数组，用一个int来代表每一个像素,按位表示方式是:0xAARRGGBB srcRgbImage = new int[imgWidth * imgHeight]; // 获取原始图片的所有像素，参见MIDP APPI文档 srcImage.getRGB(srcRgbImage, 0, imgWidth, 0, 0, imgWidth, imgHeight); shadowRgbImage = new int[srcRgbImage.length]; System.arraycopy(srcRgbImage, 0, shadowRgbImage, 0, shadowRgbImage.length); // 渐变图片的所有像素已开始都是全透明的 for (int i = 0; i < shadowRgbImage.length; i++) { shadowRgbImage &= 0x00ffffff; } new Thread(this).start(); } public void paint(Graphics g) { g.setColor(0, 0, 0); g.fillRect(0, 0, w, h); // 绘制渐变图片 g.drawRGB(shadowRgbImage, 0, imgWidth, (w - imgWidth) / 2, (h - imgHeight) / 2, imgWidth, imgHeight, true); g.setColor(0, 255, 0); g.drawString("count=" + count, w / 2, 30, Graphics.HCENTER | Graphics.TOP); } public void run() { while (true) { boolean changed = false; // 改变渐变图片的每一个像素 for (int i = 0; i < shadowRgbImage.length; i++) { // 获取渐变图片的某一像素的alpha值 int alpha = (shadowRgbImage & 0xff000000) >>> 24; // 原始图片的对应像素的alpha值 int oldAlpha = (srcRgbImage & 0xff000000) >>> 24; if (alpha < oldAlpha) { // alpha值++ shadowRgbImage = ((alpha + 1) << 24) | (shadowRgbImage & 0x00ffffff); changed = true; } } try { Thread.sleep(10); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } count++; repaint(); // 当所有像素的alpha值都达到原始值后,线程运行结束 if (!changed) { System.out.println("over"); break; } } } } April 15 彻底明白Java的IO系统
古代帝国中的图片资源节省算法{geshibot lang="javascript"}/**
效果图如下
所以一张图片的设计，像素的取舍需要跟美工配合好，需要画什么样的图片，以及需要转换的像素点。也可见MacroSpace中美工和程序是紧密地结合在一起的，做到了代码实现更方便以及用代码来节省图片资源 J2ME平台PNG图像压缩、解压与加密技术
深入J2ME配置层Java 2 Micro Edition (J2ME)是建立在一个由profiles，配置，虚拟机和主持操作系统等部分所组成的标准架构之上的。这些内容组成了完整的J2ME实时运行环境。图A显示了这些部分是如何结合在一起的。J2ME提供了两种配置： Connected Limited Device Configuration (CLDC)和 the Connected Device Configuration (CDC)。这两种配置以设备的内存footprint为基础面向不同的设备类型。 配置指定了最小的功能组和相关的Java 虚拟机 (JVM)应支持的Java类库。从概念上讲，配置层在虚拟机 (VM)的顶端运行，但当你使用一个例如CLDC和CDC的配置时，你也会涉及到相关的VM，因为二者是紧密相连的。 然而，应该注意的是在J2ME中，配置并不附属于一个特定的VM，他可以与其它的VM工作并支持所需的库。例如，CLDC也可以和应用指定基础功能的VM共同工作。关于细节，请见CLDC HotSpot应用虚拟机白页。 为了帮助你理解J2ME配置层所扮演的角色，我将对CLDC和CDC分别地进行阐述。 CLDC CLDC 是针对少于512KB内存footprint的设备的配置。CLDC采用的是KVM，它是高度优化的JVM方式，他针对的是16比特或32比特的微处理器，160到512 KB内存为基础的低端，网络连接，电池驱动的设备。典型的内存要求是128KB做有来存储KVM和相关的库。更多关于KVM的信息可以从Sun公司的KVM白页中得到。 就网络化而言，CLDC针对的是有限的和间歇性的无线连接设备，所有在J2ME CLDC之上运行的应用软件都应能在其他任何高端的Java VM上运行。当然，这需要CLDC库的支持。CLDC配置关注于I/O，网络化，安全问题，国际化问题和核心 Java库等相关的领域。 与事件处理，用户和应用程序的互动，应用程序生存期管理等内容相关的领域是由Profile来处理的。使用界面定义（对于特定的设备，如传呼机，移动电话和PDA）也在Profile层的范围之内，它建立在顶端之上，并使用J2ME配置。 Mobile Information Device Profile (MIDP)是一个J2ME profile，它定义了使用CLDC配置设备的用户界面相关的规范。 CLDC从J2SE获得绝大多数的类，但一些针对小内存footprint设备的新类并不是从J2SE APIs获得的。关于类从J2SE 做继承和新CLDC类的具体信息，可参考CLDC规范1.0a版本的6.2和6.3中的内容。Java语言规范中的一些例外是没有浮点支持，没有类实例的完成化支持和有限的错误处理能力。 在这里提到CLDC HotSpot应用也是具有相关性的，它相当于使用 CLDC配置的设备的KVM中Java VM的替换。根据Sun公司，CLDC HotSpot执行VM是一个高性能的JVM（32位，采用 CLDC v1.0规范）。他在相同的内存footprint上运行时提供比KVM高出一个数量级的更佳的性能。 CDC：完全Java平台 CDC是应用在具有较大内存，特别是2MB以上的设备上的，CDC针对有限和间歇的无线连接设备，CDC与CVM和Foundation profile共同定义了完全的J2ME环境。 CVM是为用户和嵌入设备设计的完全功能性JVM，它支持所有的Java 2 v1.3 VM安全防护，JNI, JVMDI, RMI，弱引用功能和库。本质上说，CVM具有所有一个驻留桌面系统的JVM所具有的功能。 CDC由J2SE中最小的Java数据包组成。Foundation profile由用户设备所需要的保持类库和APIs所组成。因此，如果你工作在一个以CDC为基础的J2ME环境下，你就需要更新你代码以使APIs更新换代。 CDC是CLDC的一个扩展集，所以在两种配置之间存在着向上的兼容性。CDC和Foundation profile也提供了对使用PersonalJava实时规范开发的应用程序的完全兼容。 总结 J2ME 模式体系使能了不同设备类别的“特别版”Java的创建。随着越来越多的设备制造商开始接受J2ME技术和J2ME设备使用范围的增大，更新的 J2ME profiles将得到应用。通过为开发以Java为基础的设备提供一个公共最小化平台，J2ME配置用结构化的方式使能了这些Java特别版本。 使用调色板进行手机游戏开发 （转）
J2ME移动开发平台搭建篇要进行J2ME的开发，首先必须要建立开发的平台，而在开发的平台选择上，有三种方案，在此推荐给大家。
一、功能比较全的Borland Jbuilder平台 搭建这个平台，我们必需要安装：JBUILDER 7 或 JBUILDER 8 ，BORLAND 的 MOBILESET 3.1。 可选材料有：（注意这些不是必须的，没有这些你也可以进行开发）你所想开发的手机SDK，例如要在NOKIA上开发必须准备 NOKIA DEVELOPER‘S SUITE，还可以根据自己需要加一些模拟器如7210等。 有了以上的材料就足够我们搭建一个很不错的开发平台了。 搭建步骤： （1）：安装JBUILDER，并注册。（注意：D版JBUILDER 8用户，市面上有些D版JBUILDER 8破解有问题，会导致接下来安装的MOBILESET无法被激活的情况，也就是无论你怎么配置，在MIDP页面里的选项永远是灰的，请勿使用它 盘中的破解文件，用注册机注册） （2）：正确安装JBUILDER ，并、成功注册后，安装 MOBILESET 3.1，安装完成后，需要注册，MOBILESET是免费的，你可以向BORLAND索要注册码，也可以用 附录3 中的注册码注册。 （3）：完成以上2步必须步骤后，就可以安装你选装的DEVELOPER'S SUITE和模拟器了(NOKIA SDK安装方法见附录1)。 （4）：正确完成了以上步骤，可以说这个平台已经搭建完成，就这么简单，下面你要做的就是在JBUILDER中NEW 一个PROJECT，在出现 的窗体中JDK选J2ME的，其他都使用默认的就可以了，完成配置后，再选NEW，这时候在最后的MIDP页面里两个选项应该是可选的，接下 来你就可以开发了。 2：Sun 公司官方工具，使用满方便的平台 j2me_wireless_toolkit； 搭建这个平台，我们必需要安装有：jdk1.4，j2me_wireless_toolkit1。04或j2me_wireless_toolkit2。0 beta1 可选材料有：（注意这些不是必须的，没有这些你也可以进行开发）你所想开发的手机SDK，例如要在NOKIA上开发必须准备NOKIA DEVELOPER‘S SUITE，还可以根据自己需要加一些模拟器如7210等(NOKIA SDK安装方法见附录1)。 有了以上的材料就足够我们搭建现在的平台。 （1）：首先安装jdk1.4，（在方法一中因为JBUILDER自带JDK所以不需要单独安装。） （2）：正确安装JDK后，才可以安装j2me_wireless_toolkit，不管1。04还是2。0 BETA1都可以，2个都装也可以。 （3）：完成以上2步必须步骤后，就可以安装你选装的DEVELOPER‘S SUITE和模拟器了(NOKIA SDK安装方法见附录1)。 （4）正确完成了以上步骤，可以说这个平台已经搭建完毕了，有些菜鸟可能会问这个j2me_wireless_toolkit是干什么的，其实它的作用就和JB UILDER差不多，用来编译你写的JAVA程序，但它本身不提供编辑等功能，所以你得用记事本或其他文本编辑软件写程序，使用方法见附录4 3：个头最小，但用起来比较复杂的平台cldc+MIDP 搭建这个平台，我们必需要安装：jdk1.4，J2ME_CLDC_ 1.04，MIDP 2.0 对这个平台的使用方法我自己到现在还不是特别清楚，只粗略的介绍一下 （1）同样首先要安装jdk1.4 （2）将J2ME_CLDC_ 1.04，MIDP 2.0和解压到同一目录下如c:\j2me下，其实这两个就是在命令行下的编译器和JBUILDER，toolkit的作用 一样，但用起来更麻烦。 （3）详细使用方法见附录5 介绍完毕，希望能对刚起步的菜鸟有帮助，有什么错误的地方还请大家指正，文章中引用了其他作者的文字，向他们表示感谢。 附录1：NOKIA SDK安装 在装完JBUILDER（其实就是看有没有装JDK，JBUILDER自带JDK）或JDK后，NOKIA的DEVELOPER‘S SUITE才能被安装，谧巴闐EVELOPER‘S SUITE后装模拟器，一定要装在NOKIA的DEVELOPER‘S SUITE的 DEVICE目录下，下面是 NOKIA的DEVELOPER‘S SUITE和一些模拟器的注册码 nds_jme_v1.1（Nokia Developer Suite”） 用户名：allyfeng 序列号：pJzPqsT0PjnMEwaTR2Ga+WiCeSk= ns40 用户名：allyfeng 序列号：HgaDbt1HpXFucqDp97ThNjvN468= 7210 用户名：allyfeng 序列号：89YPeBKM6tzssXLLi5OxuDdhcyk= Nokia 6650模拟器 注册信息： 用户名：allyfeng 序列号：PLkvtJRKbzplqIXRqyb0czF969w= 附录2：注册机使用方法 这里我推荐使用JBLicenseGenW.exe 使用简单，装好JBUILDER后使用，可以注册J7，J8。先生成注册码，在SAVE一下就行。 对于那些先用试用版注册码，后来再替换的方法我没试过。 如果运行JBLicenseGenW.exe没反映或出错，可能是你的JBUILDER没装好。我也不知道怎么解决。 附录3： JBuilder MobileSet 3.0.1。需要先安装JBuilder7或JBuilder8。 注册方法：新建一个文本文件，将下面的注册码复制到文件中，保存。注册时选择Active File，然后 载入该文件便可。 注册码： -----BEGIN BLOCK----- %C5%17%DE%9B%00%00%02I%DE%DAL% 2C%B2%F7%9DE%80C5%A6%E5%AF%7C% A7%06%05%D1%B1%B5%0A%955L%87%E 5%E6%5B%8C%0D%01%A9%EE%EB-%A9% 21%7C%E7%8A%E2%1D%B6LZ%E2%F1%F B0%E3%7B%1F%F6%E3%9A%3E%E4%1D% 2B%FD%FB%CD%5C%D6%2BO%FB%F6%89 %7F%D8j%3E%96%8C%98L%C0%03%15% 86%D3%FEt%81%1Bf%8F%DD%B6%02%D 76z%FE%E4%8B%5B%D8%02%1D%BD%F1 %B0P%A9%27%13%F6%8F%AE%0D%8A%7 FR%99%ED%93%22%82v%2B%E7%9B%AF T%C3Q%1F%8E%CC%BFp%A52%26%DC%9 F%8EC%D3%1CU%D1%AA%ADb%DA%1B%2 B%A0%8A%D2i%B3%0C%20%C2%DC%81r %E3G%0A%90%E4%B2e%9D%11%3A%F1% 90%D2_%A0%7BO%C0%A4%A3%17%98%1 E%21%EE%9D%B3%24%9AK%1A%A5%BE% BE%3E%EAg-%F1%B6%9BL%BA-%2F%F8 %D5%E2%23%C0j%27%E8%B2%ADS%F6t %03%C0%D6%E7%3E%E96%28%95%C3%E 7Z%F4%3EH%B3%B3%D2Y%A9F%16%92% 93%88%1A%A4mW%85%A1%92i%B0%5BQ %A7%EF%87I%D2%7F%3D%8A%A0%A3Y% BEQc%EA%8A%8E%08%95%02%7E%9A%F F%DBe%80%40%04%8A%DB%BBd%A7g%3 D%C7%A6%E0%7C%90%29*%EC%E0%ABx %D4%29N%D0%DA%A6P%D6%11%1E%ED% 90%9D%1B%E7S%10%FD%B6%BF%14%A9 %07P%B9%B0%C1O%9Ds%14%8C%87%99 e%F7%18%1E%9C%EB%FDc%B4%13a%D9 %9D%8D%2C%97%1A8%C1%AF%D3x%87% 7FG%E6%94%98%26%90j%10%C8%EC%8 64%C2SN%E5%9E%D8T%EFez%BB%8A%D 1%20%CD5%0B%FC%E3%CC%19%89jv%C 4%D9%E1r%A2z0%BE%DD%A4j%91h%0D %E3%F1%9C%2B%ED%06%60%E1%F2%FA X%CA%18F%DE%FB%ABw%93q%29%D5%E E%BFF%A4%3E%02%B0%C6%ADH%98p%0 D%CE%FE%FC%7F%AE%07%04%8E%C7%F 9d%AD%29%7C%DF%AF%B5V%98%20%1C %A5%89%ED%7F%B5RU%EC%AB%FCQ%AF Z%5C%F4%9B%A7%5D%8C_%17%D8%CF% B1%5B%D6G%28%B2%EE%F8%02%A0%0F o%C3%B4%ECG%9E%3D%26%C2%CC%F4e %FF_%3C%A5%91%BB%1C%D3%26V%DA% F7%95u%BD%3Cf%D9%EE%E7%27%C8%1 5%3D%E7%A3%9E_%AAR%7C%92%F8%CD %13%9D%1E4%9F%84%EFT%8F%5CO%DB %B0%D4l%8ChN%83%E4%CE%3F%F32v% 95%AA%A2f%97p%2F%E5%E5%D8d%91h C -----END BLOCK----- 附录4：toolkit用法 启动工具包，真是说起来容易做起来难，说不定你初此动手的时候就偏偏不知道该如何启动了，OK，那 就找到KToolbar程序启动它。 按下Create Project按钮创建新项目。系统提示你输入项目的名字和主MIDlet类的名字，随便你写什么 都可以，该类应该在启动应用程序时运行 。工具包会用你输入的项目名为你创建项目目录。 检查显示的项目属性是否正确，待会儿我们还要回头再检查一下这些设置。 用记事本编写Java程序源代码（或者拷贝现有的代码）并把程序代码保存到前面KToolbar建立的以你工 程名命名的目录的src子目录里。 按下Build按钮编译，之后按下Run按钮在测试模拟器中测试程序。 附录5： 首先下载以下软件： JDK 1.2或者更高版本 http://java.sun.com/j2se/ 有限连接设备配置（clcdhttp://www.sun.com/software/communitysource/j2me/download.html MIDhttp://java.sun.com/products/midp/ 注意：你需要JDK中的JAVAC命令来编译MIDlets。 下载、解压缩以上软件，放到以下被推荐的目录中： C:\JDK1.2 C:\j2me │ MIDP │ CLCD 此文章假设目录为C:\j2me 为了测试MIDP应用程序，你需要安装MIDP和CLCD。 配置运行环境 设置环境变量，修改PATH添加MIDP和JDK的工作路径。 设置环境变量 设置PATH中的变量，用文本编辑器打开autoexec.bat，或者在开始运行中敲入sysedit命令，并且插入 以下两行，我们假定你的*作系统和JDK 全部安装在C盘下。 SET PATH=%PATH%;%JAVAHOME%\BIN; PATH=C:\WINDOWS;C:\WINDOWS\COMMAND;C:\JDK\BIN; C:\j2me\midp\bin;%PATH% 检查你的环境变量设置是否成功 在命令行下键入如下命令： c:\midp 回车。 此时应该弹出一个窗口，如（图1）。 设置屏幕颜色 C:\set SCREEN DEPTH=8 C:\midp -des criptor run.jad 效果见图2 好了，你现在可以准备测试第一个MIDP了。 HelloMIDlet的描述文件 关于HelloMIDlet例子的代码，http://wireless.java.sun.com/midp/articles/intro/ ;查阅。 MIDlet-Name: HelloMIDlet MIDlet-Version: 1.0.0 MIDlet-Vendor: Sun Microsystems, Inc. MIDlet-Des cription: A Simple Example MIDlet-Info-URLhttp://java.sun.com/j2me/ ; MIDlet-Jar-URL: hello.jar MIDlet-Jar-Size: 1063 MicroEdition-Profile: MIDP-1.0 MicroEdition-Configuration: CLDC-1.0 MIDlet-1: HelloMIDlet,, HelloMIDlet 编译，校验，打包和运行 编译 在命令行下键入如下命令（应在一行中实现）： C:\javac -d .\ -bootclasspath c:\pathTo\MIDP\classes HelloMIDlet.java 校验 C:\preverify -classpath c:\j2me\MIDP\classes; C:\Examples\ FirstMIDlet 一个校验过的CLASS文件被写到目录C:\Examples\output\ 中。 进入到C:\Examples\output\目录中，键入如下命令： C:\Example\output>midp FirstMIDlet 打包 把HelloMIDlet.class文件打包成JAR文件。 C:\jar cf hello.jar HelloMIDlet.class 运行 C:\midp -des criptor hello.jad March 23 J2ME 2D小游戏入门之周边工具类虽然我们有了midp2.0的支持，但是有时还是需要一些辅助工具，方便我们使用。这怕是在进行真正的游戏设计之前最有趣的了。 1、首先是一个ImageTools工具类，提供一个方法帮助调用Image public class ImageTools { protected ImageTools() {} public static Image getImage(String str){ Image img=null; try { img = Image.createImage(str); } catch (Exception ex) { System.out.println(ex); } finally{ return img; } } } 2．GameObject，提供一个通用的游戏对象。 有了Sprite类，为什么还要GameObject呢？其实我们一般是将Sprite，看作成一个高级的Image，往往一个Sprite要被多个 游戏对象调用，GameObject其实就是Sprite的状态类。GameObject提供简单的生命周期概念，动画更新速度； public class GameObject { public Sprite sprite;//内置的Sprite public boolean alive;//存活标记 private int lifecount=0;//生命周期计数器 public int lifetime=0;//生命周期，以桢为单位 public int speed=0;//动画桢更新速度，（0至无穷，0代表每一桢跟新一个画面） private int animcount=0;// /动画桢更新计数器 public GameObject(Image img,int width,int height){ sprite=new Sprite(img,width,height); reset(); } public void move(int dx,int dy){//相对移动 sprite.move(dx,dy); } public void moveto(int x,int y){//绝对移动 sprite.setPosition(x,y); } public void update(){//更新状态，动画桢更新，生命周期更新 if(!alive) return; if(++animcount>speed){ animcount=0; sprite.nextFrame(); if(lifetime!=0 && ++lifecount>lifetime) alive=false; } } public void paint(Graphics g){//Paint if(!alive) return; sprite.paint(g); } public void reset(){//复位 alive=true; lifecount=0; animcount=0; sprite.setFrame(0); } } 3.封装字体类，你需要漂亮的字体吗？ 我们经常需要用图片来输出文字，一个方便的字体类是必须的。我们希望仅仅提供一个图片，一个图片所描述的字符的数组，来初始化一个字体类。字体类提供一个类似Textout的方法，方便得在一个位置输出信息。先封装一个简单的版本，只支持英文和数字，并且输出不能自动换行。 可能你有一个简单的思路，就是简单的保存字符数组，当打印的时候遍历数组，来查找每个字符在sprite的frameseq中的index，但当我们打印 一个字符串的时候就会发现，太多的遍历操作耽误了宝贵时间，这里我们使用一个小技巧用容量换取速度，我们知道Character. hashCode()可以返回字符的ascii编码，常用字符将返回1-127；利用这一点，我们开辟一个128的数组charhash，将输入的字符c所在图片index存入charhash[c. hashCode()]中。以后也用这种映射方法来读取字符。charhash的元素初值为-1，以后只要数值大于0就是有效值。 public class Font { Sprite sprite; //Sprite int width,height; //每个char的尺寸 int[] charhash; //储存1-127个常见字符在sprite的frameseq中的位置 Graphics g; public Font(Graphics g,Image img, int width, int height, char[] chars) { this.g=g; sprite=new Sprite(img,width,height); this.width=width; this.height=height; charhash=new int[128]; for (int i = 0; i < charhash.length; i++) { charhash=-1;//没有代表此字符的图片 } Character c; for (int i = 0; i < chars.length; i++) { c=new Character(chars); charhash[c.hashCode()]=i; } } public void drawChar(char ch, int x, int y){ Character c=new Character(ch); int hashcode=c.hashCode(); sprite.setPosition(x,y); if(hashcode>=0){ sprite.setFrame(charhash[hashcode]); sprite.paint(g); } } public void drawString(String str, int x, int y){ int length=str.length(); for (int i = 0; i < length; i++) { drawChar(str.charAt(i),x+width*i,y); } } } 这样只要有一个实例font,就可以调用font.drawString(“hello”,0,0); 在0，0位置输出漂亮的图片字符串。怎么样还挺好使的吧。 常见J2ME系统属性及其作用列表
在J2ME开发中，我们经常需要和手机系统进行交互，获得一些和系统相关的信息，在J2ME API设计中，提供了一系列的系统属性，可以让我们来进行获得，下面就一一进行介绍。
表1 CLDC、MIDP和JTWI属性
表2 可选包属性
表3 MMAPI属性
表4 Wireless Messaging API属性
表5 FileConnection API
使用这些属性，可以获得在程序运行过程中需要的很多和系统相关的信息，也可以使用表2中的属性来获得手机是否支持对应的可选包等信息。
实际使用示例：
String name = System.getProperty(“microedition.platform”);
注意：如果需要获得JVM或jad文件中的信息，需要使用MIDlet类中的getAppProperty方法，其属性名则需要查阅jad文件的设定，和本文所述的属性名无关。 March 22 厂商SDK的下载地址现在支持Java的手机厂商很多，现将常用的手机厂商SDK和下载地址说明一下： 1、 Nokia Nokia不愧为手机行业的老大，对于j2me的支持也是一流的，有专门的网站提供SDK和各种文档说明。 网址是：http://forum.nokia.com.cn/sch/index.html 2、 Siemens Siemens对于J2ME的支持也不错，它提供了SDK，模拟器需要独立安装。下载地址如下： https://communication-market.siemens.de/portal/main.aspx?LangID=0&MainMenuID=2&LeftID=2&pid=1&cid=0&tid=3000&xid=0 3、 SonyEricsson SonyEricsson SDK以及自己的模拟器，下载地址为： http://developer.sonyericsson.com/site/global/docstools/java/p_java.jsp http://mobilityworld.ericsson.com.cn/development/download_hit.asp 4、 Motorola Motorola提供了专门的SDK，内部包含模拟器，下载地址为： http://www.motocoder.com/motorola/pcsHome.jsp 5、 SamSung SamSung也提供了专门的SDK和模拟器，下载地址为： http://developer.samsungmobile.com/eng/front_zone/bbs/bbs_main.jsp?p_menu_id=1500 6、 NEC： NEC也提供了集成模拟器的SDK，下载地址为： http://www.nec-mfriend.com/cn/ February 22 优秀的J2ME网站集锦http://java.sun.com/javame/
一些实用的图形用户界面方法
这个函数已反复应用于多个手机应用软件平台 用法：参数定义：str——要分割的字符串 半透明技术（限MIDP2.0） // 获得半透明图片，透明度从0到10共分为11个等级 灰度图转化函数// 得到灰度图
图片透明效果
常见属性(Property)及其作用列表在J2ME开发中，我们经常需要和手机系统进行交互，获得一些和系统相关的信息，在J2ME API设计中，提供了一系列的系统属性，可以让我们来进行获得，下面就一一进行介绍。
表1 CLDC、MIDP和JTWI属性
表2 可选包属性
表3 MMAPI属性
表4 Wireless Messaging API属性
表5 FileConnection API
使用这些属性，可以获得在程序运行过程中需要的很多和系统相关的信息，也可以使用表2中的属性来获得手机是否支持对应的可选包等信息。
实际使用示例：
String name = System.getProperty(“microedition.platform”);
注意：如果需要获得JVM或jad文件中的信息，需要使用MIDlet类中的getAppProperty方法，其属性名则需要查阅jad文件的设定，和本文所述的属性名无关。
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
|
