Question

java的j2me小程序一个求解释

一个j2me的程序 两个java文件 在WTK中命名的项目MIDlet类名为FirstOne 两个程序如下
**************************
我想知道这个程序的执行顺序 先从哪里开始再到哪里 在到哪里 。。最后在哪里结束 一些方法 比如其中的paint()[Canvas] run()[Runnable]是怎么被调用的 谢谢 新手 多多指教

import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
public class FirstOne extends MIDlet
{
private MyCanvas mycan;
private Display dis;
public FirstOne()
{
dis=Display.getDisplay(this);
mycan=new MyCanvas();
}
protected void startApp()
{ dis.setCurrent(mycan);}
protected void pauseApp()
{}
protected void destroyApp(boolean un)
{ dis.setCurrent(null);}
}
*****************************************8
import java.lang.Runnable;
import javax.microedition.lcdui.*;
import java.lang.Thread;
public class MyCanvas extends Canvas implements Runnable
{
static final int SeaGreen=0x578b2e;
static final int Tomato=0x4763ff;
private static int width;
private static int height;
public MyCanvas()
{
width=getWidth();
height=getHeight();
try
{
Thread mythread=new Thread(this);
mythread.start();
}
catch(Exception e)
{ e.printStackTrace();}
}
public void paint(Graphics g)
{
g.setColor(SeaGreen);
g.fillRect(0,0,width,height);
g.setColor(Tomato);
g.drawString("I am a developer.",0,0,Graphics.TOP|Graphics.LEFT);
}
public void run()
{
while(true)
{
try
{
repaint();
Thread.sleep(100);
}
catch(Exception e)
{ e.printStackTrace();}
}
}

}

Answer 1

/**
* 闲的无聊 解释着玩
* 我就按照
* [步骤] 说明 给你说清楚了
*/
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;

public class FirstOne extends MIDlet {

private MyCanvas mycan;
private Display dis;

/**
* [1] 先构造方法 这没什么可说的
*/
public FirstOne() {
//这句话获得当前的屏幕对象
dis = Display.getDisplay(this);
//调用MyCanvas构造 这句话到[2]
mycan = new MyCanvas();
//构造完毕 到[4]
}
/**
*
* [4] 为什么会到这里 是因为这是j2me运行机制决定的 原理就跟那个paint()一样 由系统调用
* (就是别人规定这么运行的,他规定运行完了midlet的构造方法,就要运行startApp
* 而你继承重写了这个方法 所以将会调用你的代码
*
*/
protected void startApp() {
//将当前屏幕设置成mycanvas
//mycanvas开始接管屏幕显示工作 这里的setCurrent方法会调用一次paint()
//所以没绘制线程的情况下也会执行一次绘制任务.造成两个线程在一个时间段内都会执行同一段代码
dis.setCurrent(mycan);
/**
* 到此主线程后续没有和你自写的程序相关任务了.
* 主线程无非也就是一个由别人(开发java的人)写好的public void run()方法,
* 别人让主线程处理完了你的程序以后干什么,或是什么都不做,不是咱们所关心的.但重要的是要知道主线程一直都存在,
* 理解这点很重要.
* 你可以控制主线程结束,但那样你的程序也就结束了.
*/
}

protected void pauseApp() {
}

protected void destroyApp(boolean un) {
dis.setCurrent(null);
}
}

import java.lang.Runnable;
import javax.microedition.lcdui.*;
import java.lang.Thread;

public class MyCanvas extends Canvas implements Runnable {
static final int SeaGreen = 0x578b2e;
static final int Tomato = 0x4763ff;
private static int width;
private static int height;

/**
* [2] 构造
*/
public MyCanvas() {
width = getWidth();
height = getHeight();
try {
//创建线程
Thread mythread = new Thread(this);

/**
* 顺便解释一下调用机制,这个不是三言两语就能说清楚的 只能看你的领悟力了
* 先说线程
* 都知道代码是 自顶而下 一句一句运行(如果不开任何线程,只有一个线程 这个线程就是主线程).而且是由cpu一句一句运行.
* 但出了多线程这个概念 这时候发生变化了 比如两个线程
* 你可以理解为 进入了双核cpu时代 相当于多了一个cpu 同时开工 可以运行两个程序
* 放到这里来说 就是 主线程(主cpu)往下一句一句运行代码 而新开一个线程(另一个cpu)负责每隔多少时间画一下屏幕(称之为绘制线程) 两cpu同时配合执行同一个程序
* 而主线程还在自顶而下运行着,并不知道什么时候过了1000毫秒 需要刷新屏幕 而且这时候正在运行其他代码 也无法调用repaint();进行绘制任务.所以需要绘制线程计算
* 时间,时间到了执行这段代码. (多线程很复杂,而且跟cpu运行有本质区别,要想真正参透那就多看看线程文章,多动手练练吧)
*
* 调用机制 :语法你得懂吧,不懂无能为力...
*
* 有如下三个类
* Canvas.java System.java MyCanvas.java
* [伪代码]
* Canvas 里有个方法
* protected abstract void paint();
*
* System 里有个方法 有个属性
* Canvas c =new MyCanvas();
* void doSomeThing(){
* c.paint();
* }
*
* MyCanvas继承Canvas
* MyCanvas extends Canvas{
* protected void paint(){
* //绘制任务;
* System.out.println("调用我");
* }
* }
*
* 你能明白System是如何调用的 MyCanvas 的paint()而不是Canvas 的paint()吗?
* 实际上Canvas 和 System是由别人写好的,而MyCanvas你自己写的
* 换句话说 你能明白系统是如何调用的 你写的类的方法 而不是系统自己的canvas的方法吗?
* 系统调用的抽象方法paint()而不用管是由谁实现的paint()方法,系统只需要知道有这么个方法而且我能用就行了.
* 或许你对这句话有疑问 系统如何知道 我写的 Mycanvas?
* 这句话Canvas c =new MyCanvas();
* 这个是在 FirstOne里的这句话
* dis.setCurrent(mycan);
* 相当于 System.setCanvas(new MyCanvas());
* 但咱没源代码,实际上内部也是这么实现的.
* 按照这个原理就不难理解为啥会调用paint(Graphics g);
* 而runnable的run()也是由于你这原因而运行的,所以所有看似现成的类都是由别人(java开发人员)写好的,别人规定怎么运行 ,
* 你按照别人的规定的规则写出新的类或方法,别人就能使用你写出的方法或类.所以整个j2me类库就是别人定的规则,
* 想玩游戏吗?就得按照游戏的规则来.就和么简单
*
*
*/
//线程开始 这样同时就有两个线程(两段代码)开始运行了 绘制线程进入[3] 主线程继续运行 这时候是同时运行的[3][2]
//mythread.start()会调用Runnable接口的run方法 可以看看jdk源代码 Thread类实现
mythread.start();
} catch (Exception e) {
e.printStackTrace();
}
//构造方法运行完毕 主线程回到[1] 继续运行
}

/**
* [5] 根据调用机制 所以不是由你自己直接调用paint()
* 而参数Graphics g是由系统传给你的 所以也不需关心Graphics g是怎么来的
*/
public void paint(Graphics g) {
g.setColor(SeaGreen);
g.fillRect(0, 0, width, height);
g.setColor(Tomato);
g.drawString("I am a developer.", 0, 0, Graphics.TOP | Graphics.LEFT);
//paint执行完毕绘制线程退回到[6]
}

/**
* [3] 绘制线程进入
*/
public void run() {
/**
*线程会执行run()方法里的代码一次 因为是死循环的代码
*所以绘制线程不停的执行这段代码
*while里边的代码
*/
while (true) {
try {
//repaint()会调用paint()方法 进行屏幕绘制
// 至于为什么 写repaint()这个方法的人规定的 没啥好说的 绘制线程进入[5]
repaint();
//[6]
//绘制线程休眠100毫秒
Thread.sleep(100);
} catch (Exception e) {
e.printStackTrace();
}
//又会回到while (true) 调用repaint()
}
//永远不会执行到这里(例外是打断线程休眠)
}
}

洋洋洒洒写了一大堆,不知所云 如果你真能理解java运行机制 线程之类的 一通百通 像为什么[1]会首先运行就会小case一样 加油吧~

Answer 2

paint() 当程序运行到这个界面的时候自动调用， 而 start()是你自己主动调用的，每当你用repaint()函数时就会再调用paint()函数进行重绘

Answer 3

我补充一点，你在实例化对象时，去
try
{
Thread mythread=new Thread(this);
mythread.start();
}使用this为当前对象分配一个线程 ，但此时对象空间是生成了，是否进行了实例化不确定，这样会不会有问题，如果异常在此时抛出，好像会出现问题。

Answer 4

paint()[Canvas]
run()[Runnable] 是
MyCanvas 里面的两个方法，当类给实例化的时候，就可以调用了
定义一个新的类Test类
下下面一个方法
public static void main(String [] args){
MyCanvas c = new MyCanVas();
c.run();
}

这样就可以调用了，那个先，那个后，就看你先调用那个了