j2me上面实现图片的特效

最新推荐文章于 2020-07-17 09:53:26 发布
最新推荐文章于 2020-07-17 09:53:26 发布
阅读量530 收藏
点赞数
分类专栏： 技术文章 文章标签： j2me image null import string class

 最近需要完成一个在j2me上面实现图片的特效 （缩放，裁剪，调整大小，镜像，对比度亮度调整，黑白，线条，粉笔画,蒙版）等功能，于是写了一些算法完成了以上功能，系统条件：MIDP2.0，cldc1.1

代码如下：

ImageUtil

/*
 * ImageUtil.java
 *
 * Created on 2008年1月11日, 上午9:26
 *
 */


/**
 *
 * @author alajl
 */


import javax.microedition.lcdui.*;
import javax.microedition.lcdui.game.Sprite;


public class ImageUtil
{
    public static final int TURN_LEFT = 1;
    public static final int TURN_RIGHT = 2;


    /*
    *获取图片RGB数据，并返回大小为width*height大小的一维数组
    */
    public int[] getPixels(Image src)
    {
        int w = src.getWidth();
        int h = src.getHeight();
        int[] pixels = new int[w * h];
        src.getRGB(pixels, 0, w, 0, 0, w, h);
        return pixels;
    }

 
    /*
    *将pixels[]里的数据，生成一张图片，图片宽为w，高为h
    */
    public Image drawPixels(int[] pixels, int w, int h)
    {
        Image image = Image.createRGBImage(pixels, w, h, true);
        pixels = null;
        return image;
    }


    /*
    *调整图片大小
    *destW 调整后的宽，destH调整后的高
    */ 
    public  Image effect_resizeImage(Image src, int destW, int destH)
    {
        int srcW = src.getWidth();
        int srcH = src.getHeight();

 
        int[] destPixels = new int[destW * destH];
       
        int[] srcPixels = getPixels(src);

            for (int destY = 0; destY < destH; ++destY)
            {
                for (int destX = 0; destX < destW; ++destX)
                {
                    int srcX = (destX * srcW) / destW;
                    int srcY = (destY * srcH) / destH;
                    destPixels[destX + destY * destW] = srcPixels[srcX + srcY
                            * srcW];
                }
            }

 
        return drawPixels(destPixels, destW, destH);
    }

  
   /*
   * 调整图片亮度与对比度。  contrast 对比度，light 亮度
   */
   public Image effect_light_contrast(Image src,double contrast,int light)
   {
            int srcW = src.getWidth();
            int srcH = src.getHeight(); 
            int[] srcPixels = getPixels(src);
            int r = 0;
            int g = 0;
            int b = 0;
            int a = 0;
            int argb;
     //公式y =ax+b   a为对比度，b为亮度
     //int para_b  = light - 127 * (light - 1);
     for (int i = 0; i < srcH; i++)
           {
              for(int ii=0;ii<srcW;ii++)
        {
                      argb = srcPixels[i*srcW+ii]; 
        a = ((argb & 0xff000000) >> 24); // alpha channel
                      r =((argb & 0x00ff0000) >> 16); // red channel
                      g =((argb & 0x0000ff00) >> 8); // green channel
                      b =(argb & 0x000000ff); // blue channel
                      r =(int)( r*contrast+light);                    
        g =(int)( g*contrast+light);
        b =(int)( b*contrast+light);
                    
         /*r =(int)((r -127 ) * contrast + 127+para_b);
         g =(int)((g -127 ) * contrast + 127+para_b);
         b =(int)((b -127 ) * contrast + 127+para_b);*/
         if(r>255)
                               r = 255;
                       else if(r<0) r=0;
                       if(g>255)
                               g = 255;
                       else if(g<0) g=0;
                       if(b>255)
                               b = 255;
                       else if(b<0) b=0;
               srcPixels[i*srcW+ii] = ((a << 24) | (r << 16) | (g << 8) | b);

        }
     }
         return drawPixels(srcPixels, srcW, srcH);
   }
 
 
    /*
   * 图片镜像特效
   */
    public Image effect_mirror(Image src)
    {
          int srcW = src.getWidth();
          int srcH = src.getHeight(); 
          int[] srcPixels = getPixels(src);
          int len;
          int temp;
          for (int i = 0; i < srcH; i++)
          {
              len = (i+1)*srcW;
              for(int ii=0;ii<srcW/2;ii++)
              {  
                 temp=srcPixels[i*srcW+ii];
                 srcPixels[i*srcW+ii]=srcPixels[len-1-ii];
                 srcPixels[len-1-ii]=temp;
              }
           }
           return drawPixels(srcPixels, srcW, srcH);
    }

      /*
   * 图片剪切，cut_xpos，cut_ypos 切割框的起始位置坐标，cut_width，cut_height 切割框的宽与高
   */
    public Image effect_cut(Image src,int cut_xpos,int cut_ypos,int cut_width,int cut_height)
    {
          int srcW = src.getWidth();
          int srcH = src.getHeight(); 
          int[] srcPixels = getPixels(src);
          int[] desPixels = new int[cut_width*cut_height];
          int argb;
   int num = 0;
          for (int i = 0; i < srcH; i++)
          {
            if(i >= cut_ypos&&i<cut_height+cut_ypos)
            {
                 for(int ii=0;ii<srcW;ii++)
          {
                    if(ii>=cut_xpos && ii<cut_width+cut_xpos)
      {
                         desPixels[num] = srcPixels[i*srcW+ii];   
                         num++;
                        
        }
   }
             }
         }
           return drawPixels(desPixels, cut_width, cut_height);
    }


    /*
   * 图片叠加，将src和image合成一张图片，x_pos，y_pos一般为0,0,也可以为自定义值
   */
    public Image effect_image_add_image(Image src,Image image,int x_pos,int y_pos)
    {  
             Image temp  = Image.createImage(src.getWidth(),src.getHeight());
      Graphics g = temp.getGraphics();
             //g.drawImage(src,x_pos,y_pos,Graphics.LEFT|Graphics.TOP);
      //g.drawImage(image,x_pos,y_pos,Graphics.LEFT|Graphics.TOP);*/
             int alpha = 168;
             int []srcRgbdata   =   new   int[src.getWidth()*src.getHeight()];  
             int []desRgbdata   =   new   int[image.getWidth()*image.getHeight()]; 
             src.getRGB(srcRgbdata,0,src.getWidth(),0,0,src.getWidth(),src.getHeight());  
             image.getRGB(desRgbdata,0,image.getWidth(),0,0,image.getWidth(),image.getHeight());   
             g.drawRGB(getTransImg(alpha,srcRgbdata,desRgbdata),0,src.getWidth(),0,0,src.getWidth(),src.getHeight(),false);  
             src=null;  
             image=null; 
             return temp;
    }
   
     /*
   * 图片上添加字符
   */
    public Image effect_image_add_str(Image src,String str,int x_pos,int y_pos)
    {
             Image temp = Image.createImage(src.getWidth(),src.getHeight());
      Graphics g = temp.getGraphics();
             g.drawImage(src,0,0,Graphics.LEFT|Graphics.TOP);
             g.setColor(0x000000);
   g.drawString(str,x_pos,y_pos,Graphics.LEFT|Graphics.TOP);
             return temp;
    }
 
     /*
   * 图片特效负片
   */
    public Image effect_negative(Image src)
    {
         int srcW = src.getWidth();
         int srcH = src.getHeight(); 
         int[] srcPixels = getPixels(src);
         int r = 0;
         int g = 0;
         int b = 0;
         int a = 0;
         int argb;  
         for (int i = 0; i < srcH; i++)
         {
              for(int ii=0;ii<srcW;ii++)
        {
   argb = srcPixels[i*srcW+ii];
                        a = ((argb & 0xff000000) >> 24); // alpha channel
                        r =255-((argb & 0x00ff0000) >> 16); // red channel
                        g =255-((argb & 0x0000ff00) >> 8); // green channel
                        b =255-(argb & 0x000000ff); // blue channel
                        srcPixels[i*srcW+ii] = ((a << 24) | (r << 16) | (g << 8) | b);
        }
         }
        return drawPixels(srcPixels, srcW, srcH);

        
    }

      /*
   * 图片特效黑白
   */
     public Image effect_black_white(Image src)
    {
         int srcW = src.getWidth();
         int srcH = src.getHeight(); 
         int[] srcPixels = getPixels(src);
         int r = 0;
         int g = 0;
         int b = 0;
         int a = 0;
         int argb;
         int temp;
         
         for (int i = 0; i < srcH; i++)
         {
              for(int ii=0;ii<srcW;ii++)
        {
   argb = srcPixels[i*srcW+ii];
                        a = ((argb & 0xff000000) >> 24); // alpha channel
                        r = ((argb & 0x00ff0000) >> 16); // red channel
                        g = ((argb & 0x0000ff00) >> 8); // green channel
                        b = (argb & 0x000000ff); // blue channel
                        temp = (int)(.299*(double)r+.587*(double)g+.114*(double)b);
                        r = temp;
                        g = temp;
                        b = temp;
                        srcPixels[i*srcW+ii] = ((a << 24) | (r << 16) | (g << 8) | b);
        }
         }
        return drawPixels(srcPixels, srcW, srcH);

        
    }
    
      /*
   * 图片特效粉笔画
   */
     public Image effect_crayon(Image src)
     {
         int srcW = src.getWidth();
         int srcH = src.getHeight(); 
         int[] srcPixels = getPixels(src);
         int r = 0;
         int g = 0;
         int b = 0;
         int a = 0;
         int argb;  
         int r1 = 0;
         int g1 = 0;
         int b1 = 0;
         int a1 = 0;
         int r2 = 0;
         int g2 = 0;
         int b2 = 0;
         int a2 = 0;
        
         for (int i = 0; i < srcH; i++)
         {
              for(int ii=0;ii<srcW;ii++)
       {
                  argb = srcPixels[i*srcW+ii];
                  a = ((argb & 0xff000000) >> 24); // alpha channel
                  r = ((argb & 0x00ff0000) >> 16); // red channel
                  g = ((argb & 0x0000ff00) >> 8); // green channel
                  b = (argb & 0x000000ff); // blue channel
                  if(i+1 == srcH)
                  {
                       r1= 0;
                       g1= 0;
                       b1=0;
                  }
                  else
                  {
                     argb = srcPixels[(i+1)*srcW+ii];
                     //a1 = ((argb & 0xff000000) >> 24); // alpha channel
                     r1 = ((argb & 0x00ff0000) >> 16); // red channel
                     g1 = ((argb & 0x0000ff00) >> 8); // green channel
                     b1 = (argb & 0x000000ff); // blue channel
                  }
                  if(ii+1 == srcW){
                       r2= 0;
                       g2= 0;
                       b2=0;
                  }
                  else
                  {
                      argb = srcPixels[i*srcW+ii+1];
                      r2 = ((argb & 0x00ff0000) >> 16); // red channel
                      g2 = ((argb & 0x0000ff00) >> 8); // green channel
                      b2 = (argb & 0x000000ff); // blue channel
                  }
                 // rr1=(r1-r2)^2  rr2=(r1-r3)^2
                  r = (int)Math.sqrt((double)(2*(r-r1)*(r-r1)+(r-r2)*(r-r2)));
                  g = (int)Math.sqrt((double)(2*(g-g1)*(g-g1)+(g-g2)*(g-g2)));
                  b = (int)Math.sqrt((double)(2*(b-b1)*(b-b1)+(b-b2)*(b-b2)));
                  r =255-r; // red channel
                  g =255-g; // green channel
                  b =255-b; // blue channel
                  srcPixels[i*srcW+ii] = ((a << 24) | (r << 16) | (g << 8) | b);
              }
         }
         return drawPixels(srcPixels, srcW, srcH);
     }
    
         /*
   * 图片特效蒙版
   */
      public Image effect_hoodwink(Image src)
    {
         int srcW = src.getWidth();
         int srcH = src.getHeight(); 
         int[] srcPixels = getPixels(src);
         int r = 0;
         int g = 0;
         int b = 0;
         int a = 0;
         int argb;

         
         for (int i = 0; i < srcH; i++)
         {
              for(int ii=0;ii<srcW;ii++)
        {
   argb = srcPixels[i*srcW+ii];
                        a = ((argb & 0xff000000) >> 24); // alpha channel
                        r = ((argb & 0x00ff0000) >> 16); // red channel
                        g = ((argb & 0x0000ff00) >> 8); // green channel
                        b = (argb & 0x000000ff); // blue channel
                        r = (int)(.299*(double)r);
                        g = (int)(.587*(double)g);
                        b = (int)(.114*(double)b);
                        srcPixels[i*srcW+ii] = ((a << 24) | (r << 16) | (g << 8) | b);
        }
         }
        return drawPixels(srcPixels, srcW, srcH);

        
    }
    
    private   int[]   getTransImg(int alpha,int[] srcRgbdata,int[] desRgbdata)  
    {   
           int []   tempRgbData = new int[desRgbdata.length];  
       
           int   sr  ;
           int   sg ;
           int   sb ;
           int   dr  ; 
           int   dg ;
           int   db ;
           int   tr  ;
           int   tg  ;
           int   tb  ;
           for(int   i=0;i<desRgbdata.length;i++)  
           {  
              sr   =   (srcRgbdata[i]&0xff0000)>>16;  
              sg   =   (srcRgbdata[i]&0xff00)>>8;  
              sb   =   srcRgbdata[i]&0xff;  
              dr   =   (desRgbdata[i]&0xff0000)>>16;  
              dg   =   (desRgbdata[i]&0xff00)>>8;  
              db   =   desRgbdata[i]&0xff;  
              tr   =   (sr*alpha   +   dr*(255-alpha))/255;  
              tg   =   (sg*alpha   +   dg*(255-alpha))/255;  
              tb   =   (sb*alpha   +   db*(255-alpha))/255;    
              tempRgbData[i]   =   (tr<<16)|(tg<<8)|tb;  
           }  
         return   tempRgbData;  
       }
   
         /*
   * 图片特旋转
   */
    public Image effect_rotate(Image src,int direction)
    {
        Sprite sprite = new Sprite(src);
        switch(direction)
        {
                  case 1:
                            sprite.setTransform(sprite.TRANS_ROT270);
                            break;
                  case 2:
                            sprite.setTransform(sprite.TRANS_ROT90);  
                            break;
        }
      
        Image temp = Image.createImage(src.getHeight(),src.getWidth());
  Graphics g = temp.getGraphics();
        sprite.setPosition(0,0);
        sprite.paint(g);
        return temp;  
     }

   
  

       /*
   * 图片特霓虹灯
   */
    public Image effect_neonLight(Image src)
    {
         int srcW = src.getWidth();
         int srcH = src.getHeight(); 
         int[] srcPixels = getPixels(src);
         int r = 0;
         int g = 0;
         int b = 0;
         int a = 0;
         int argb;  
         int r1 = 0;
         int g1 = 0;
         int b1 = 0;
         int a1 = 0;
         int r2 = 0;
         int g2 = 0;
         int b2 = 0;
         int a2 = 0;
        
         for (int i = 0; i < srcH; i++)
         {
              for(int ii=0;ii<srcW;ii++)
       {
                  argb = srcPixels[i*srcW+ii];
                  a = ((argb & 0xff000000) >> 24); // alpha channel
                  r = ((argb & 0x00ff0000) >> 16); // red channel
                  g = ((argb & 0x0000ff00) >> 8); // green channel
                  b = (argb & 0x000000ff); // blue channel
                  if(i+1 == srcH)
                  {
                       r1= 0;
                       g1= 0;
                       b1=0;
                  }
                  else
                  {
                     argb = srcPixels[(i+1)*srcW+ii];
                     //a1 = ((argb & 0xff000000) >> 24); // alpha channel
                     r1 = ((argb & 0x00ff0000) >> 16); // red channel
                     g1 = ((argb & 0x0000ff00) >> 8); // green channel
                     b1 = (argb & 0x000000ff); // blue channel
                  }
                  if(ii+1 == srcW){
                       r2= 0;
                       g2= 0;
                       b2=0;
                  }
                  else
                  {
                      argb = srcPixels[i*srcW+ii+1];
                      r2 = ((argb & 0x00ff0000) >> 16); // red channel
                      g2 = ((argb & 0x0000ff00) >> 8); // green channel
                      b2 = (argb & 0x000000ff); // blue channel
                  }
                 // rr1=(r1-r2)^2  rr2=(r1-r3)^2
                  r = (int)Math.sqrt((double)(2*(r-r1)*(r-r1)+(r-r2)*(r-r2)));
                  g = (int)Math.sqrt((double)(2*(g-g1)*(g-g1)+(g-g2)*(g-g2)));
                  b = (int)Math.sqrt((double)(2*(b-b1)*(b-b1)+(b-b2)*(b-b2)));
                  srcPixels[i*srcW+ii] = ((a << 24) | (r << 16) | (g << 8) | b);
              }
         }
         return drawPixels(srcPixels, srcW, srcH);
    }

}

 

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/alajl/archive/2008/04/12/2284924.aspx

caridle
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaScript图像处理(2) - 亮度对比度调整(Brightness/Contrast)
Peihong's Infinite Dimensional Space
11-15 8650
基本的图像处理操作之一是颜色操作，也就是根据一定的规则修改图像中像素的值。例如说改变图像的亮度、对比度，进行色彩替换，或者是对图像进行曲线操作，复杂一点的还有色彩空间矢量化等。 修改图像的亮度和对比度实际上是对像素值进行线性变换： r = r * alpha + beta g = g * alpha + beta b = b * alpha + beta 亮度变化比较简单，就是在上面
基于j2me的图片特效（缩放，裁剪，调整大小，镜像，对比度亮度调整，黑白，线条，粉笔画）
偷得浮生半日闲
04-12 3923
最近需要完成一个在j2me上面实现图片的特效 （缩放，裁剪，调整大小，镜像，对比度亮度调整，黑白，线条，粉笔画,蒙版）等功能，于是写了一些算法完成了以上功能，系统条件：MIDP2.0，cldc1.1 代码如下：ImageUtil /* * ImageUtil.java * * Created on 2008年1月11日, 上午9:26 * *//**
j2me图片缩放方法
夏亚欣的博客
06-04 953
今天在网上看到几个在j2me中实现图片缩放的函数，很不错，记录下来。 注:src为原始图片，destW为修改后的宽度，destH为修改后的高度   1.方法一 public static Image resizeImage(Image src, int destW, int destH) { int srcW = src.getWidth(); int srcH = src.getHeight(); int[] destP
J2ME图片浏览器
Smallearth的专栏
05-26 107
package Mypaint; import javax.microedition.midlet.*; import javax.microedition.lcdui.*; import javax.microedition.midlet.MIDletStateChangeException; public class mypaint extends MIDlet { privat...
收集了几个关于J2ME图片缩放的函数
千里积于跬步，江海成于小流
11-26 1011
收集了几个图像缩放函数，可能实现的方式很多，感觉这几个还是不错的，分享下说明：以下函数都是基于MIDP2.0的，缩放后保留透明色。代码1，resizeImage函数 public static Image resizeImage(Image src, int destW, int destH) { int srcW = src.getWidth();
j2me图片特效包及demo程序
07-08
在这个"j2me图片特效包及demo程序"中，我们主要关注的是如何在 J2ME 应用程序中处理和操作图像，实现各种视觉效果。下面我们将详细探讨这些知识点： 1. **图片加载**：在 J2ME 中，通常使用 ` javax.microedition....
java j2me上的图片抖动效果 特效
07-12
在J2ME平台上实现图片的抖动特效，是一种增强用户交互体验的技术，通常用于游戏或者动画设计中。这种特效可以通过编程实现，让图片在屏幕上以一种不规则的方式移动，营造出一种动态的视觉效果。 实现图片抖动特效的...
j2me 图片处理特效
08-24
在这个特定的"j2me 图片处理特效"资源中，我们可以深入探讨几个关键的知识点。 首先，图片处理是移动应用开发中的重要部分，特别是在游戏和娱乐应用中。J2ME提供了基本的图像操作接口，如` javax.microedition....
J2ME图片翻书特效
08-28
总的来说，J2ME图片翻书特效是通过在移动设备上利用J2ME的图形处理能力和图像操作来实现的一种高级用户界面效果。开发者需要对图像处理算法、线程管理和J2ME图形API有深入理解才能成功地创建这样的应用程序。虽然...
J2ME模拟器 QQ2007
11-11
**J2ME模拟器QQ2007** Java Micro Edition（J2ME）是Java平台的一个子集，专为资源有限的设备，如早期的移动电话和平板电脑设计。J2ME应用程序通常被打包成JAR（Java Archive）文件，可以跨支持J2ME的设备运行。...
图像处理之调整亮度与对比度
weixin_34191845的博客
03-22 1968
图像处理之调整亮度与对比度 很多时候，一张图像被过度曝光显得很白，或者光线不足显得很暗，有时候背景跟图像人物 也观察不清楚，这个时候可以通过调节图像的两个基本属性-亮度与对比度来获得整体效果 的提升，从而得到质量更高的图片。 基本原理： 图像亮度本质上图像中每个像素的亮度，每个像素的亮度本质上RGB值的大小，RGB值为0 是像素点为黑色，RGB都为25...
图像像素处理_明度/亮度/平均值/灰褐色/滤镜/灰色_canvas_js动画
07-25 2797
本文参考《写给Web开发人员看的HTML5教程》 其他滤镜可参考jacob Seidelin的Pixastic图像处理库(http://www.pixastic.com/lib),那里有超过30种javascript滤镜，均基于Mozilla的公开授权。 //明度 function grayLigtness(r,g,b,a){ var val=parseInt(
HTML5画布kineticjs照亮或变暗的图像教程
终是如此也需努力
09-03 816
照亮或变暗的图像kineticjs，我们可以使用kinetic.filters.brighten滤波器与filterbrightness财产的亮度设置。亮度属性可以设置为255和255之间的任意整数。负值变暗的图像，使图像和正面的价值观。 说明：滑动控制来调整亮度 body { margin: 0px; pad
j2me图片大小、剪切、透明等处理
阿当
02-23 885
<br />image = Image.createImage("/images.png");<br /><br /><br />图片是以位表示的一个数组。<br />对数组的处理时各种图片处理的老祖宗<br />下面是在网上摘抄的加上了一下自己处理的一个图片处理类<br />import javax.microedition.lcdui.*; import javax.microedition.lcdui.game.Sprite; public class ImageUtil { pu
粉笔画教程雪花的粉笔画画法
河南省电闪雷鸣文化传媒有限公司
07-17 1112
1.从利用粉笔画出基本的雪花形状开始，并在线条相交的中心添加填充的心形。 2.绘制华丽的雪花就是所有微小的细节。从心形的上方利用粉笔画出小小的V形装饰。 3.在每个线条之间，添加几行看起来像珍珠的圆形图案。利用粉笔画一个小圆圈，但不要实心填充，请用手指涂抹粉笔。这将使它看起来更像一个立体的圆形。 4.继续添加粉笔画出的白色圆形图案，从最靠近中心的最大圆形图案开始，逐渐变小。 5.添加从主线条伸出的小对角线。这种羽毛状的形状将与圆形形成鲜明对比。 6.用粉笔画出小小的心形盖住线条顶端。 7.用粉.
matlab下载.pdf
07-14
matlab下载下载方式及注意事项
Android系统原理及开发要点详解-从入门到精通
07-13
Android系统原理及开发要点详解 Java4 Android视频教程 Android开发视频教学 从入门到精通 Android的软件管理器的开发教程视频 Android深入浅出_Android高端课程分享试听 JavaWeb Android系统的手机防盗软件的实现 Android开发入门与实战随书视频 视频列表.txt 0.0MB 开发入门与实战代码.rar 6.1MB 第9章 我来“广播”你的“意图”——Intent和Broadcast面对面.wmv 15.1MB 第8章 移动信息仓库——Android的数据存储操作之轻轻地我保护——SharedPreferences存储-2.wmv 0.6MB 第8章 移动信息仓库——Android的数据存储操作之轻轻地我保护——SharedPreferences存储-1.wmv 24.3MB 第8章 移动信息仓库——Android的数据存储操作之Android数据存储概述.wmv 57.7MB 第7章 良好的学习开端——Android基本组件介绍之友好地互动交流——对话框(Dialog)介绍与实例-2.wmv 7.
GESP等级认证 2024年6月 C++一级真题
最新发布
07-14
GESP等级认证 2024年6月 C++一级真题 从官网上刚刚下载下来的,题都是热乎的,这可是最新真题 大家看一看瞧一瞧,走过路过不要错过,免费下载,全篇无水印,不好用随便吐槽我! 涵盖选择题,判断题,编程题,基础知识多,满满的干货,非常建议下载!!!!! 萌新小白来做做题,复习巩固都很合适!
java基于J2ME的游戏开发——贪吃蛇论文.docx
08-09
通过JDK 1.6和NetBeans 5.5开发环境，以及WTK 2.5模拟器进行测试，实现了经典游戏在移动设备上的移植，旨在满足用户对手机游戏的需求。" J2ME，全称为Java 2 Micro Edition，是Java平台的一个子集，专门用于嵌入式...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值