import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;

public class OpenConn implements Runnable {
 private HttpURLConnection conn;
 private URL url;

 // Thread thread1;

 public OpenConn(String url) throws MalformedURLException {
  this.url = new URL(url);
 }

 public void run() {
  try {
   conn = (HttpURLConnection) url.openConnection();
  } catch (IOException e) {
   e.printStackTrace();
   url = null;
  }
 }

 public HttpURLConnection getConn() {
  return conn;
 }

 public static void main(String[] args) throws Exception {
  // 创建Runnable类
  OpenConn openConn = new OpenConn(“http://www.google.com“);
  // 创建线程
  Thread thread = new Thread(openConn);
  // openConn.thread1=thread;
  thread.start();
  thread.join(10000);// wait 10 seconds
  HttpURLConnection c = openConn.getConn();
  if (c != null) {
   System.out.println(“连接网络成功…”);
   BufferedReader r = new BufferedReader(new InputStreamReader(c
     .getInputStream()));
   String s = r.readLine();
   while (s != null) {
    System.out.println(s);
    s = r.readLine();
   }
  } else {
   System.out.println(“超时错误,连接网络失败…”);
  }
 }
} 
2.通过引用Runnable接口创建

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;

public class OpenConn2 extends Thread {
 private HttpURLConnection conn;
 private URL url;

 public OpenConn2(String url) throws MalformedURLException {
  this.url = new URL(url);
 }

 public void run() {
  try {
   conn = (HttpURLConnection) url.openConnection();
  } catch (IOException e) {
   e.printStackTrace();
   url = null;
  }
 }

 public HttpURLConnection getConn() {
  return conn;
 }

 public static void main(String[] args) throws Exception {
  OpenConn2 openConn = new OpenConn2(“http://www.google.com“);
  openConn.start();
  openConn.join(10000);// wait 10 seconds
  HttpURLConnection c = openConn.getConn();
  if (c != null) {
   System.out.println(“连接网络成功…”);
   BufferedReader r = new BufferedReader(new InputStreamReader(c
     .getInputStream()));
   String s = r.readLine();
   while (s != null) {
    System.out.println(s);
    s = r.readLine();
   }
  } else {
   System.out.println(“超时错误,连接网络失败…”);
  }
 }
}
3.以匿名内部类的方式创建
即在一个方法中创建线程，当方法被调用时，线程即启动，如下：
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class OpenConn3 {
 private HttpURLConnection conn;
 private URL url;
 
 public static void main(String[] args){
  try{
   OpenConn3 open3= new OpenConn3();
   open3.strartMyThread();
  }catch(Exception ex){
   System.out.println(ex.toString());
  }
 }
  public void strartMyThread() throws Exception{
   this.url =new URL(“http://www.google.com“);
         java.lang.Runnable runner=new Runnable(){
          public void run(){
           try {
            conn = (HttpURLConnection) url.openConnection();
           } catch (IOException e) {
            e.printStackTrace();
            url = null;
           }
          }

         };
         Thread openConn=new Thread(runner);
         openConn.start();
         openConn.join(10000);// wait 10 seconds

   if (conn != null) {
    System.out.println(“连接网络成功…”);
    BufferedReader r = new BufferedReader(new InputStreamReader(conn
      .getInputStream()));
    String s = r.readLine();
    while (s != null) {
     System.out.println(s);
     s = r.readLine();
    }
   } else {
    System.out.println(“超时错误,连接网络失败…”);
   }

  }
}

public class mainmidlet extends midlet implements commandlistener {

private display display; 
private form form = new form(“wellcome!!”); 
private command okcommand = new command(“ok”,command.ok,1);
//选择ok,换到下一个屏幕 
private form ns ; 
private stringitem si = new stringitem(“first screen”,”~_~”); 
public mainmidlet() 
{ 
    form.addcommand(okcommand); 
    form.append(si); 
} 
public void startapp() { 
    display = display.getdisplay(this);

    display.setcurrent(form); 
    form.setcommandlistener(this);//对form加入commandlistener

} 
public void pauseapp() {

} 
public void destroyapp(boolean b){

} 
public void commandaction(command c,displayable s) 
{ 
    if(c==okcommand) 
    { 
        ns = new nextscreen(display,form);//最关键的地方在这里：form：将父屏幕对象传下去，方便后退时返回父屏幕) 
        display.setcurrent(ns); 
    }

}

} 
在这个midlet中，定义了一个display对像display。 以及一个两个displayable对象form form及stringitem si。运行后显示在屏幕当中。 还有个一command okcommand，其作用是触发下一个屏幕。 在public void commandlistener中可以看到，当当前按下的按钮是okcommand时，初始化一个nextscreen对象 ns = new nextscreen(display,form); 将display和form传入，作用就是进行屏幕的切换。 下面是nextscreen的实现： nextscreen.java 第二个屏幕的代码
import javax.microedition.lcdui.*; 
public class nextscreen extends form implements commandlistener {

private display display; 
private displayable parent; 
private command backcommand = new command(“back”,command.back,1); 
private stringitem si = new stringitem(“secondscrean”,”~_~”); 
public nextscreen(display d,displayable p) 
{ 
    super(“nextscreen”); 
    display = d; 
    parent = p; 
    append(si); 
    addcommand(backcommand); 
    setcommandlistener(this);

} 
public void commandaction(command c,displayable s) 
{ 
//返回上一个屏幕 
    if(c==backcommand) 
    { 
    display.setcurrent(parent); 
    } 
}

} 
它继承自form类。 在nextscreen中又定义了一个display display，将用它来标识当前的元素显示在哪一个屏幕中。 一个form form，一个stringitem si。这是当前屏幕中要显示的东东：) 构造函数中的super(“secondscreen”);的作用是使得nextscreen可以直接调中其父类form中的函数。 backcommand的作用是返回上一个屏幕。 将form，si及backcommand加入nextscreen中，一个nextscreen的实例就完成了。在主程序(mainmidlet)中，就是ns。
接下来，最关键的地方，就是在mainmidlet中的这一句：display.setcurrent(ns); 就是把ns在当前的屏幕中显示出来!这样就可以看到nextscreen中定义的各个元素(form,si)了!
然后想返回原屏幕，怎么办呢？这时nextscreen中的backcommand就起作用了。 仔细看这两句： 在mainmidlet.java中： ns = new nextscreen(display,form); 它将form也传了进去。它有什么用呢？ 在nextscreen的构造函数中： dispaly =d; 这一句其实等于：nextscreen.display = mainmidlet.display; 这样，nextscreen就得到了当前的屏幕，它就随意的在上面放东东了。 parent = p; 这一句其实等于：nextscreen.parent = mainmidlet.form; 从字面意思不难理解，原来是把主程序的form当成parent(父母)，这样就得到当前屏幕的前一个屏幕中所显示的内容!! 然后在commandaction中，如果backcommand按下了，则执行display.sercurrent(parent);这样，又把原来的屏幕给show出来了：)

       Canvas类是Displayable的子类，主要用来需要处理低级事件，例如键盘按键事件等，以及需要绘制屏幕的程序。在实际的使用过程，一般都通过继承Canvas来利用该类提供的功能。Canvas类是一个抽象类，继承该类的时候必须覆盖paint方法。

       Canvas类的功能主要包含以下几类：

1、  获得手机屏幕属性

l         getHeight——获得屏幕可用高度

l         getWidth——获得屏幕宽度

l         isDoubleBuffered——是否支持双缓冲

l         hasPointerEvents——是否支持指针设备

l         hasPointerMotionEvents——是否支持指针动作，例如拖拉事件

l         hasRepeatEvents——是否支持重复按键

实际开发过程中，可以在程序中直接调用这些方法，通过返回值获得相应的属性信息。

2、  绘制方法

l         paint——绘制方法

l         repaint——重新绘制方法

paint方法需要在界面类中覆盖，然后就可以书写功能，而再需要重新绘制的时候手动调用repaint方法。

3、  事件处理

低级用户界面的事件处理分为两种：按键事件和指针事件(处理触摸屏手机的低级事件)。

支持按键事件的方法主要有三个：

l         keyPressed——按键按下的事件

l         keyReleased——按键释放的事件

l         keyRepeated——重复按键的事件

支持指针事件的方法也有三个：

l         pointerPressed——指针设备按下事件

l         pointerReleased——指针设备释放事件

l         pointerDragged——指针设备拖拉事件

在实际的编程中，只需要在界面类中覆盖这些方法，然后在方法的内部书写代码即可，在发生这些事件的时候，系统会自动调用这些方法。

4、  其他方法

l         getGameAction——将按键映射成游戏动作

l         getKeyCode——将游戏动作转换为键值

l         getKeyName——将键值转换为按键名称

l         hideNotify——在Canvas界面被隐藏的时候系统自动调用该方法

l         showNotify——当Canvas界面显示的时候系统自动调用该方法

l         serviceRepaints——强制系统重新绘制

以上方法除了hideNotify、showNotify需要在子类中覆盖，系统会自动调用以外，其他的方法都可以直接调用。

5、  系统的熟悉主要分为两个部分：

l         按键的键值

KEY_NUM0、KEY_NUM1、KEY_NUM2、KEY_NUM3、KEY_NUM4、KEY_NUM5、KEY_NUM6、KEY_NUM7、KEY_NUM8、KEY_NUM9分别对应手机键盘的0-9数字键，KEY_STAR对应*号键，KEY_POUND对应#号键。各个功能键的键值在Canvas类没有进行定义，所以各个厂商，甚至厂商的不同型号手机之间，的键值都有所不同。但是功能键的键值均小于0。

l         游戏动作

UP、DOWN、LEFT、RIGHT和FIRE，分别对应上、下、左、右和确定键，在实际的手机中一般分别对应2、8、4、6和5键以及功能键中的方向键。GAME_A、GAME_B、GAME_C、GAME_D分别对应游戏中的A、B、C和D键，分别映射成手机上的1、3、7、9键，或者是7、9、*和#键。

在实际的事件处理中，使用游戏可以达到在不同的手机之间通用。

              在MIDP2.0中，又新增了两个方法，分别是：

l         setFullScreenMode——控制屏幕是全屏幕显示还是一般模式显示

l         sizeChanged——当屏幕尺寸变化的时候，系统会自动调用该方法。

上面系统的介绍了Canvas类提供的功能，下面就介绍一下它的使用。当调用Display对象的setCurrent方法显示Canvas界面时，系统首先调用Canvas对象的构造方法，然后调用paint方法实现绘制，这样我们就可以看到实际的界面了。而以后，当界面坐标发生变化以后，必须手动调用repaint方法实现绘制。

以下是一些在实际的编程过程中，需要注意的一些问题：

l         坐标参数化或者根据屏幕的宽度和高度生成坐标，从而提高界面的移植性。

l         在程序运行过程中，paint方法经常被反复调用，所以一般在该方法中只放置绘制的代码，而把逻辑处理的代码放在别的位置。

l         在进行低级事件处理代码编写中，对于游戏按键，尽量使用游戏动作进行编程，其他按键才直接使用键值，从而提高事件处理代码的移植性。

l         因为hideNotify和showNotify方法会在界面隐藏和重新显示时，被系统自动调用，所以可以覆盖这两个方法，在其中实现暂停的逻辑。

l         尽量使用双缓冲技术，避免屏幕的闪烁，除非手机不支持双缓冲。

l         显示其他界面的时候，注意要关闭线程，并释放资源。