j2me源代码（j2me最新版）

本篇文章给大家谈谈j2me源代码，以及j2me最新版对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、J2ME 五子棋程序及论文
• 2、j2me书中代码如何打包？
• 3、我在网上载了个j2me源代码，有bin，res，src，三个文件夹。 怎么用eclipse打开这个工程。并重新编译
• 4、谁有J2ME源代码？
• 5、高分求一段J2ME源代码

J2ME 五子棋程序及论文

J2ME-MIDP1.0小游戏入门-五子棋1.0

发布时间：2006.03.09 12:30 来源：CSDN 作者：

作者：yinowl

2005年1月

介绍

这是我学习j2me入门后的第一个作品，当然这也是一个极其简单的作品（没有电脑AI，只能是两个人对战），现在我把当时的设计思路写成这篇文档，希望对想入门j2me的朋友在j2me的流程,按键响应，绘图等方面有所帮助，同时也希望大家指出错误和改进程序。

注意

代码列出解释的形式仿照《J2ME Game Programming》一书，按照程序功能思路给出相关代码，一个文件的代码会根据功能在不同的小节给出，文章结束了，代码也就完整了。这不同于通常书中的代码以文件为单位一次全部给出，我认为这样更有助于让大家了解一个程序从设计到最后完成的思路。

设计

数据结构：由于五子棋是一个二维棋类游戏，所有首先想到的是定义一个Chesses类来表示棋子，Chesses有一个boolean型的变量isPlayer1来区分该棋子是哪玩家下的，然后用一个Chess类型的二维数组来包含棋盘上的所有棋子。考虑到移动设备的资源有限，尽可能减少系统资源占用，我考虑不在数组建立后直接生成数组的每一个对象，而是把每一个棋子对象(Chesses)放在游戏的进行中生成，也就是说在游戏进行时，玩家每下一步棋，在数组相应位置生成该棋子的对象，这样可以避免还没有下的棋子在一开始就占用了系统内存

流程：游戏按照棋子的二维数组进行绘制棋子，玩家下棋后，程序修改数组相应位置，设置isPlayer1值，然后重新绘制(repaint)，就更新了棋盘界面。由于游戏的功能简单，也为了使游戏的操作尽可能的简便，我不在游戏进入时设计菜单，而是直接开始对战，在对战界面，设置了重新开始和退出的按钮。即运行即玩，一键开始，一键重来，一键退出。

玩家切换：棋类游戏有一个问题需要注意，就是提示当前由哪方下棋，为了节省界面空间，简化游戏界面，我在棋盘外围加了一个3个像素宽的框，框的颜色就是当前下棋方的颜色，如图：

应用程序类：Gobang.java

接下来就开始完成游戏中的每一个类，首先就是一个MIDlet类。Gobang类继承自MIDlet类，用于连接设备的应用程序管理器（Application Manager），通过方法startApp,pauseApp,destroyApp来通知游戏的开始，暂停和销毁结束。源代码如下：

package com.occo.j2me.game.gobang;

import javax.microedition.lcdui.Display;

import javax.microedition.midlet.MIDlet;public class Gobang extends MIDlet { GobangCanvas gobang;//定义游戏界面的Canvas类GobangCanvas的对象gobang public Gobang() {

super();

gobang=new GobangCanvas(this);//生成GobangCanvas类的对象gobang

} protected void startApp(){

Display.getDisplay(this).setCurrent(gobang);

//在屏幕上绘出游戏见面gobang

} protected void pauseApp(){

} protected void destroyApp(boolean arg0){

}}

游戏界面类：GobangCanvas.java

GobangCanvas类是游戏的核心类，继承自Canvas，此类将完成游戏的逻辑、绘图、控制、互动等所有功能，此类的框架代码如下：

package com.occo.j2me.game.gobang;import javax.microedition.lcdui.Canvas;

import javax.microedition.lcdui.Command;

import javax.microedition.lcdui.CommandListener;

import javax.microedition.lcdui.Displayable;

import javax.microedition.lcdui.Graphics;public class GobangCanvas extends Canvas implements CommandListener{ protected Gobang gobang;

public GobangCanvas(){

} public GobangCanvas(Gobang gobang){

this.gobang=gobang;

} protected void paint(Graphics g) {

}}

棋子类：Chesses.java

此类定义了一个棋子，棋盘上的每一个棋子都对应着一个Chesses的对象，整个棋盘是一个Chesses类型的二维数组，源代码如下：

package com.occo.j2me.game.gobang; public class Chesses { boolean isPlayer1;

public Chesses() {

} public Chesses(boolean isPlayer1) {

this.isPlayer1=isPlayer1;

}}

添加图形图像

到现在，我们已经完成了游戏的一个基本框架，接下来，我们就可以来绘制游戏的每一个部件了

首先是五子棋的一些初始设置，添加如下代码到GobangCanvas.java

...

int empty;//游戏界面到屏幕边缘的留空

int canvasW,canvasH;//画布的长和宽

int chessLength;//棋子的直径

int chessMapLength,chessMapGrid,chessGridLength;

//棋盘的边长，棋盘一边格子数，每格宽度

int chessMapX,chessMapY;//棋盘左上角x,y坐标

int selectedX,selectedY;//选择框在棋盘格局上的x,y位置

boolean isPlayer1;//是否是玩家1

Chesses[][] chesses;//棋子数组

boolean newGame;//是否是新的游戏 public GobangCanvas(Gobang gobang){

newGame=true;

empty=10;

canvasW=getWidth()-empty;canvasH=getHeight()-empty;

chessMapGrid=15;

chesses=new Chesses[chessMapGrid+1][chessMapGrid+1];

if(canvasWcanvasH){

chessMapLength=canvasH-canvasH%chessMapGrid;

chessMapX=(canvasW-chessMapLength)/2+empty/2;

chessMapY=(canvasH%chessMapGrid)/2+empty/2;

}

else{

chessMapLength=canvasW-canvasW%chessMapGrid;

chessMapX=(canvasW%chessMapGrid)/2+empty/2;

chessMapY=(canvasH-chessMapLength)/2+empty/2;

}

chessGridLength=chessMapLength/chessMapGrid;

chessLength=chessGridLength-1;

selectedX=selectedY=chessMapGrid/2;

isPlayer1=true;

}

最先要绘制的是棋盘，棋盘是正方形，但屏幕有矩形的，所以棋盘边长要按短边计，但短边未必是棋盘格子数的整数倍，因此

棋盘边长 = 短边 - 短边 % 格子数

因为棋盘要居中，所以在算左上角坐标时，记得也要把留空(empty)除以2，以下是画棋盘的代码：

protected void paintMap(Graphics g){

for(int i=0;ichessMapGrid;i++){

for(int j=0;jchessMapGrid;j++){

g.setColor(128,128,128);

g.drawRect(chessMapX+j*chessGridLength,

chessMapY+i*chessGridLength,

chessGridLength,chessGridLength);

}

}

}

然后是绘制选择框，注意：选择框的selectedX,selectedY并不是在画布上的x,y坐标，而是在棋子数组(chesses)中的位置，源代码如下：

protected void paintSelected(Graphics g){

g.setColor(0,0,255);

g.drawRect(chessMapX+selectedX*chessGridLength-chessGridLength/2,

chessMapY+selectedY*chessGridLength-chessGridLength/2,

chessGridLength,chessGridLength);

}

接着是按照棋子二维数组绘制已经下了的棋子。玩家每下一次棋，就修改数组，在重新绘图的时候就能绘出，源代码如下：

protected void paintChesses(Graphics g){

for(int i=0;i=chessMapGrid;i++){

for(int j=0;j=chessMapGrid;j++){

if(chesses[i][j]!=null){

if(chesses[i][j].isPlayer1)

g.setColor(255,255,255);

else

g.setColor(255,0,0);

g.fillArc(chessMapX+j*chessGridLength-chessLength/2,

chessMapY+i*chessGridLength-chessLength/2,

chessLength,chessLength,0,360);

}

}

}

}

最后是绘制玩家提示框，并且把所有部件的绘制汇总在paint()方法中，注意绘制的顺序，显而易见，应该先绘制提示框-棋盘-选择框-棋子：

protected void paintPlayer(Graphics g,boolean isPlayer1){

if(isPlayer1)

g.setColor(255,255,255);

else

g.setColor(255,0,0);

g.drawRect(1,1,getWidth()-2,getHeight()-2);

g.drawRect(2,2,getWidth()-4,getHeight()-4);

g.drawRect(3,3,getWidth()-6,getHeight()-6);

}

protected void paint(Graphics g) {

g.setColor(0x00000000);

g.fillRect(0, 0, getWidth(), getHeight());

paintPlayer(g,isPlayer1);

paintMap(g);

paintSelected(g);

paintChesses(g);

}

响应玩家操作

接下来应该添加命令按钮和游戏操作控制。我们在游戏中需要有两个按钮，重新开始和退出，此外还必须接收玩家控制选择框的操作上下左右和着棋，添加代码到GobangCanvas.java：

Command exitCmd;

Command restartCmd; public GobangCanvas(Gobang gobang){

...

restartCmd = new Command("重新开始", Command.SCREEN, 0);

exitCmd = new Command("退出", Command.EXIT, 0);

addCommand(restartCmd);

addCommand(exitCmd);

setCommandListener(this); }

private void init(){

if(newGame){

chesses=new Chesses[chessMapGrid+1][chessMapGrid+1];

isPlayer1=true;

selectedX=selectedY=chessMapGrid/2;

}

}

public void commandAction(Command c, Displayable d) {

if (c == exitCmd) {

gobang.destroyApp(false);

gobang.notifyDestroyed();

}else if(c==restartCmd){

init();//初始化棋盘，把棋盘清空，重新开始游戏

repaint();

}

}

protected synchronized void keyPressed(int keyCode) {

int action = getGameAction(keyCode);

if (action == Canvas.LEFT ) {

selectedX=(--selectedX+chessMapGrid+1)%(chessMapGrid+1);

}

else if (action == Canvas.RIGHT) {

selectedX=(++selectedX)%(chessMapGrid+1);

}

else if (action == Canvas.UP) {

selectedY=(--selectedY+chessMapGrid+1)%(chessMapGrid+1);

}

else if (action == Canvas.DOWN) {

selectedY=(++selectedY)%(chessMapGrid+1);

}

else if (action == Canvas.FIRE) {

if(chesses[selectedY][selectedX]==null){

chesses[selectedY][selectedX]=new Chesses(this.isPlayer1);

//checkWin();

this.isPlayer1=!this.isPlayer1;//切换下棋方

}

}

repaint();

}

private void checkWin(){

}

至此，游戏的所有绘图部分全都给出，有一点需要指出，双缓冲显示技术，由于现在有的手机已直接内置了双缓冲，这里我们就不在详细说明，有兴趣可以查阅相关文档。

游戏输赢

最后要说的是判断游戏的输赢，在游戏的响应玩家操作部分，我留有一个方法checkWin()，大家可以自己思考设计算法来判断游戏的输赢，其实不要也无所谓，因为既然是两个人类在下棋，输赢一眼就看出来了。

j2me书中代码如何打包？

用netbeans创建的工程可以直接在内置的模拟器中运行，可以成功运行后，在项目的文件夹中会生成dist文件夹，里面有lib,jar,jad三个文件，将dist文件夹拷贝到手机中，点击jar包安装，就可以安装到手机中，然后你就可以在手机上测试你的程序啦～

我在网上载了个j2me源代码，有bin，res，src，三个文件夹。 怎么用eclipse打开这个工程。并重新编译

eclipse新建一个项目如果新的j2me项目有res，src这2个目录就把你下载的覆盖,如果没有就把你下载的res和src下的所有文件拷贝到项目跟目录下,然后千万别忘记f5刷新这个项目

谁有J2ME源代码？

import javax.microedition.lcdui.*;

import javax.microedition.lcdui.game.*;

public class ExampleGameCanvas extends GameCanvas implements Runnable{

private boolean isPlay;

private long delay;

private int currentX,currentY;

private int width;

private int height;

public ExampleGameCanvas(){

super(true);

width=getWidth();

height=getHeight();

currentX=width/2;

currentY=height/2;

delay=20;

}

public void start(){

isPlay=true;

Thread t=new Thread(this);

t.start();

}

public void stop(){isPlay=false;}

public void run(){

Graphics g=getGraphics();

while(isPlay==true){

input();

drawScreen(g);

try{Thread.sleep(delay);}

catch(Exception e){}

}

}

private void input(){

int keyStates=getKeyStates();

//左键

if((keyStates LEFT_PRESSED)!=0)

currentX=Math.max(0,currentX-1);

//右键

if((keyStates RIGHT_PRESSED)!=0)

if(currentX+5width)

currentX=Math.min(width,currentX+1);

//上键

if((keyStates UP_PRESSED)!=0)

currentY=Math.max(0,currentY-1);

if((keyStates DOWN_PRESSED)!=0)

if(currentY+10height)

currentY=Math.min(height,currentY+1);

}

//显示

private void drawScreen(Graphics g){

g.setColor(0xffffff);

g.fillRect(0,0,getWidth(),getHeight());

g.setColor(0x0000ff);

g.drawString("x",currentX,currentY,Graphics.TOP|Graphics.LEFT);

flushGraphics();

}

}

import javax.microedition.midlet.*;

import javax.microedition.lcdui.*;

public class ExampleGameCanvasMidlet extends MIDlet {

private Display display;

public void startApp() {

display = Display.getDisplay(this);

ExampleGameCanvas gameCanvas = new ExampleGameCanvas();

gameCanvas.start();

display.setCurrent(gameCanvas);

}

public Display getDisplay() {

return display;

}

public void pauseApp() {

}

public void destroyApp(boolean unconditional) {

exit();

}

public void exit() {

System.gc();

destroyApp(false);

notifyDestroyed();

}

}

这是一个本人写的小游戏（初学者）

高分求一段J2ME源代码

import javax.microedition.lcdui.*;

import javax.microedition.media.*;

import javax.microedition.media.control.*;

import javax.microedition.midlet.*;

import java.io.*;

import javax.microedition.io.*;

public class PlayerMIDlet extends MIDlet implements CommandListener {

private Display display;

private List lst;

private Command start = new Command("Play",Command.SCREEN, 1);

private Command exit = new Command("Exit",Command.EXIT,2);

int currentPlaying = -1;

//Sound Player object.

static Player bbsounds[];

private Player tonePlayer;

public PlayerMIDlet(){

display = Display.getDisplay(this);

sound_init();

createTonePlayer();

}

protected void startApp() {

String[] elements = {"Play airhorn.wav","Play intro.midi","Play TuneSequence"};

lst = new List("Menu", List.IMPLICIT, elements, null);

lst.setCommandListener(this);

lst.addCommand(start);

display.setCurrent(lst);

}

private void reset(){

}

protected void pauseApp() {

try {

if(bbsounds[currentPlaying] != null bbsounds[currentPlaying].getState() == bbsounds[currentPlaying].STARTED) {

bbsounds[currentPlaying].stop();

} else {

defplayer();

}

}catch(MediaException me) {

reset();

}

}

protected void destroyApp(boolean unconditional) {

lst = null;

try {

defplayer();

}catch(MediaException me) { }

}

public void commandAction(Command c , Displayable d){

int index = lst.getSelectedIndex();

System.out.println("Playing Sound .....");

if(c == start){

if (index == 0){

sound_play(0);

}

if(index == 1){

sound_play(1);

}

if(index == 2){

playTones();

}

}

if(c == exit){

this.destroyApp(true);

}

}

void defplayer() throws MediaException {

try{

if (bbsounds[currentPlaying] != null) {

if(bbsounds[currentPlaying].getState() == bbsounds[currentPlaying].STARTED) {

bbsounds[currentPlaying].stop();

}

if(bbsounds[currentPlaying].getState() == bbsounds[currentPlaying].PREFETCHED) {

bbsounds[currentPlaying].deallocate();

}

if(bbsounds[currentPlaying].getState() == bbsounds[currentPlaying].REALIZED ||

bbsounds[currentPlaying].getState() == bbsounds[currentPlaying].UNREALIZED) {

bbsounds[currentPlaying].close();

}

}

bbsounds = null;

}catch(Exception e){

}

}

public void sound_init()

{

try

{

bbsounds = new Player[ 3 ];

InputStream in = getClass().getResourceAsStream("airhorn.wav");

try

{

bbsounds[0] = Manager.createPlayer(in, "audio/X-wav");

}catch( Exception e ){

//System.out.println("Exception in Sound Creation ");

}

in = null;

InputStream is = getClass().getResourceAsStream("intro.midi");

try

{

bbsounds[1] = Manager.createPlayer(is, "audio/midi");

is = null;

}catch( Exception e ){

//System.out.println("Exception in Sound Creation ");

}

}catch( Exception e){}

}

public void sound_play(int id)

{

//System.out.println("Playing ID is "+id);

sound_stop( currentPlaying );

currentPlaying = id;

try

{

bbsounds[ id ].realize();

System.out.println("Playing Sound...");

bbsounds[ id ].start();

}catch(Exception e){

//System.out.println("Playing Exception");

}

return;

}

public void sound_stop( int id)

{

try{

if(id!=-1){

bbsounds[ id ].deallocate();

bbsounds[ id ].stop();

tonePlayer.stop();

}

}catch(Exception ex){

//System.out.println("Stop Sound Exception ");

}

return;

}

private void createTonePlayer() {

/**

* "Mary Had A Little Lamb" has "ABAC" structure.

* Use block to repeat "A" section.

*/

byte tempo = 30; // set tempo to 120 bpm

byte d = 8; // eighth-note

byte C4 = ToneControl.C4;;

byte D4 = (byte)(C4 + 2); // a whole step

byte E4 = (byte)(C4 + 4); // a major third

byte G4 = (byte)(C4 + 7); // a fifth

byte rest = ToneControl.SILENCE; // rest

byte[] mySequence = {

ToneControl.VERSION, 1, // version 1

ToneControl.TEMPO, tempo, // set tempo

ToneControl.BLOCK_START, 0, // start define "A" section

E4,d, D4,d, C4,d, E4,d, // content of "A" section

E4,d, E4,d, E4,d, rest,d,

ToneControl.BLOCK_END, 0, // end define "A" section

ToneControl.PLAY_BLOCK, 0, // play "A" section

D4,d, D4,d, D4,d, rest,d, // play "B" section

E4,d, G4,d, G4,d, rest,d,

ToneControl.PLAY_BLOCK, 0, // repeat "A" section

D4,d, D4,d, E4,d, D4,d, C4,d // play "C" section

};

try{

tonePlayer = Manager.createPlayer(Manager.TONE_DEVICE_LOCATOR);

tonePlayer.realize();

ToneControl c = (ToneControl)tonePlayer.getControl("ToneControl");

c.setSequence(mySequence);

} catch (IOException ioe) {System.err.println("Initializing Tone");}

catch (MediaException me) { }

}

public void playTones() {

if (tonePlayer != null){

try {

System.out.println("Playing Sound...");

tonePlayer.prefetch();

tonePlayer.start();

} catch (MediaException me) {

//System.err.println("Problem starting player");

} // end catch

} // end if

} // end playTone

}

import java.io.*;

import javax.microedition.io.*;

import javax.microedition.lcdui.*;

import javax.microedition.midlet.*;

import javax.microedition.media.*;

import javax.microedition.media.control.*;

public class AudioMidlet extends MIDlet

implements CommandListener, Runnable {

private Display mDisplay;

private List main;

Player player=null;

VolumeControl vc;

public void startApp() {

mDisplay = Display.getDisplay(this);

main = new List("AudioMIDlet", List.IMPLICIT);

main.append("music1", null);

main.append("music2", null);

main.append("music3", null);

main.addCommand(new Command("Exit", Command.EXIT, 0));

main.addCommand(new Command("Play", Command.SCREEN, 0));

main.setCommandListener(this);

mDisplay.setCurrent(main);

}

public void pauseApp() {}

public void destroyApp(boolean unconditional) {}

public void commandAction(Command c, Displayable s) {

if (c.getCommandType() == Command.EXIT)

notifyDestroyed();

else {

Form waitForm = new Form("Loading...");

mDisplay.setCurrent(waitForm);

Thread t = new Thread(this);

t.start();

}

}

public void run() {

playFromResource();

}

private void playFromResource() {

try {

int i=main.getSelectedIndex();

InputStream in=null;

switch(i)

{

case 0:

in = getClass().getResourceAsStream("/chimes.wav");

player = Manager.createPlayer(in, "audio/x-wav");

player.start();

break;

case 1:

in = getClass().getResourceAsStream("/chord.wav");

player = Manager.createPlayer(in, "audio/x-wav");

player.start();

break;

case 2:

in = getClass().getResourceAsStream("/music.wav");

player = Manager.createPlayer(in,"audio/x-wav");

player.start();

break;

}

}

catch (Exception e) {

showException(e);

return;

}

mDisplay.setCurrent(main);

}

private void showException(Exception e) {

Alert a = new Alert("Exception", e.toString(), null, null);

a.setTimeout(Alert.FOREVER);

mDisplay.setCurrent(a, main);

}

}

//把上面两个java文件放在一个包里，我的是在Netbeans里编的，还要属性里改一下，就是在MIDlet里增加一下

//另外你要播放什么文件自己加在包里，程序里你也可以适当改一下参数

j2me源代码的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于j2me最新版、j2me源代码的信息别忘了在本站进行查找喔。