j2me上面实现图片的特效 （缩放，裁剪，调整大小，镜像，对比度亮度调整，黑白，线条，粉笔画,蒙版）等功能

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

系统条件：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);
     }
 
}
 
 
 
 
 
 

fengyeen
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
j2me 的关于图片的处理 源码(缩放，裁剪，调整大小，镜像，对比度亮度调整，黑白，线条，粉笔画)
05-30
本文将深入探讨如何使用J2ME进行图片处理，包括缩放、裁剪、调整大小、镜像翻转、对比度和亮度调整、黑白效果、线条艺术以及粉笔画效果。我们将以`ImageUtil.java`为例，讲解源码中封装的类和方法。 首先，`...
基于j2me的图片特效处理类
06-27
基于j2me的图片特效处理类（缩放，裁剪，调整大小，镜像，对比度亮度调整，黑白，线条，粉笔画）
基于j2me的图片特效（缩放，裁剪，调整大小，镜像，对比度亮度调整，黑白，线条，粉笔画）
偷得浮生半日闲
04-12 3918
最近需要完成一个在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
粉笔画教程雪花的粉笔画画法
河南省电闪雷鸣文化传媒有限公司
07-17 1108
1.从利用粉笔画出基本的雪花形状开始，并在线条相交的中心添加填充的心形。 2.绘制华丽的雪花就是所有微小的细节。从心形的上方利用粉笔画出小小的V形装饰。 3.在每个线条之间，添加几行看起来像珍珠的圆形图案。利用粉笔画一个小圆圈，但不要实心填充，请用手指涂抹粉笔。这将使它看起来更像一个立体的圆形。 4.继续添加粉笔画出的白色圆形图案，从最靠近中心的最大圆形图案开始，逐渐变小。 5.添加从主线条伸出的小对角线。这种羽毛状的形状将与圆形形成鲜明对比。 6.用粉笔画出小小的心形盖住线条顶端。 7.用粉.
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图片特效包及demo程序
07-08
开发者可以遍历图片的每个像素，根据对比度和亮度系数调整 RGB 值。对于亮度调整，可以简单地加减一个常数值；对比度调整则需要对颜色值进行缩放和偏移。 7. **黑白效果**：可以将彩色图片转换为灰度图片，方法是将...
PDA.rar_PDA_j2me_j2me 图片_j2me 文件_j2me 通信
09-24
在移动设备领域，个人数字助手（PDA）与Java ME（J2ME）技术结合，为开发者提供了在手机上实现类似PDA功能的平台。本文将深入探讨如何使用J2ME进行通信录管理、文件操作以及图片处理，同时介绍一个名为"PDAPDemo"的...
收集了几个关于J2ME图片缩放的函数
千里积于跬步，江海成于小流
11-26 1011
收集了几个图像缩放函数，可能实现的方式很多，感觉这几个还是不错的，分享下说明：以下函数都是基于MIDP2.0的，缩放后保留透明色。代码1，resizeImage函数 public static Image resizeImage(Image src, int destW, int destH) { int srcW = src.getWidth();
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
centos7安装jdk1.8新
07-08
centos7安装jdk1.8
2024年东南亚防火门市场深度研究及预测报告.pdf
07-08
东南亚位于我国倡导推进的“一带一路”海陆交汇地带，作为当今全球发展最为迅速的地区之一，近年来区域内生产总值实现了显著且稳定的增长。根据东盟主要经济体公布的最新数据，印度尼西亚2023年国内生产总值（GDP）增长5.05%；越南2023年经济增长5.05%；马来西亚2023年经济增速为3.7%；泰国2023年经济增长1.9%；新加坡2023年经济增长1.1%；柬埔寨2023年经济增速预计为5.6%。 东盟国家在“一带一路”沿线国家中的总体GDP经济规模、贸易总额与国外直接投资均为最大，因此有着举足轻重的地位和作用。当前，东盟与中国已互相成为双方最大的交易伙伴。中国-东盟贸易总额已从2013年的443亿元增长至 2023年合计超逾6.4万亿元，占中国外贸总值的15.4％。在过去20余年中，东盟国家不断在全球多变的格局里面临挑战并寻求机遇。2023东盟国家主要经济体受到国内消费、国外投资、货币政策、旅游业复苏、和大宗商品出口价企稳等方面的提振，经济显现出稳步增长态势和强韧性的潜能。 本调研报告旨在深度挖掘东南亚市场的增长潜力与发展机会，分析东南亚市场竞争态势、销售模式、客户偏好、整体市场营商环境，为国内企业出海开展业务提供客观参考意见。 本文核心内容： 市场空间：全球行业市场空间、东南亚市场发展空间。 竞争态势：全球份额，东南亚市场企业份额。 销售模式：东南亚市场销售模式、本地代理商 客户情况：东南亚本地客户及偏好分析 营商环境：东南亚营商环境分析 本文纳入的企业包括国外及印尼本土企业，以及相关上下游企业等，部分名单 QYResearch是全球知名的大型咨询公司，行业涵盖各高科技行业产业链细分市场，横跨如半导体产业链（半导体设备及零部件、半导体材料、集成电路、制造、封测、分立器件、传感器、光电器件）、光伏产业链（设备、硅料/硅片、电池片、组件、辅料支架、逆变器、电站终端）、新能源汽车产业链（动力电池及材料、电驱电控、汽车半导体/电子、整车、充电桩）、通信产业链（通信系统设备、终端设备、电子元器件、射频前端、光模块、4G/5G/6G、宽带、IoT、数字经济、AI）、先进材料产业链（金属材料、高分子材料、陶瓷材料、纳米材料等）、机械制造产业链（数控机床、工程机械、电气机械、3C自动化、工业机器人、激光、工控、无人机）、食品药品、医疗器械、农业等。邮箱：market@qyresearch.com
赚积分午点爬虫，我也没太看懂
07-08
赚积分午点爬虫，我也没太看懂
右键菜单功能实现.html
07-08
html+js+css实现 右键菜单功能
手机 App 测试.xmind
最新发布
07-08
手机 App 测试.xmind
Java软件开发实战 Java基础与案例开发详解 10-8 自定义异常类 共5页.pdf
07-07
完整版：https://download.csdn.net/download/qq_27595745/89522468 【课程大纲】 1-1 什么是java 1-2 认识java语言 1-3 java平台的体系结构 1-4 java SE环境安装和配置 2-1 java程序简介 2-2 计算机中的程序 2-3 java程序 2-4 java类库组织结构和文档 2-5 java虚拟机简介 2-6 java的垃圾回收器 2-7 java上机练习 3-1 java语言基础入门 3-2 数据的分类 3-3 标识符、关键字和常量 3-4 运算符 3-5 表达式 3-6 顺序结构和选择结构 3-7 循环语句 3-8 跳转语句 3-9 MyEclipse工具介绍 3-10 java基础知识章节练习 4-1 一维数组 4-2 数组应用 4-3 多维数组 4-4 排序算法 4-5 增强for循环 4-6 数组和排序算法章节练习 5-0 抽象和封装 5-1 面向过程的设计思想 5-2 面向对象的设计思想 5-3 抽象 5-4 封装 5-5 属性 5-6 方法的定义 5-7 this关键字 5-8 javaBean 5-9 包 package 5-10 抽象和封装章节练习 6-0 继承和多态 6-1 继承 6-2 object类 6-3 多态 6-4 访问修饰符 6-5 static修饰符 6-6 final修饰符 6-7 abstract修饰符 6-8 接口 6-9 继承和多态 章节练习 7-1 面向对象的分析与设计简介 7-2 对象模型建立 7-3 类之间的关系 7-4 软件的可维护与复用设计原则 7-5 面向对象的设计与分析 章节练习 8-1 内部类与包装器 8-2 对象包装器 8-3 装箱和拆箱 8-4 练习题 9-1 常用类介绍 9-2 StringBuffer和String Builder类 9-3 Rintime类的使用 9-4 日期类简介 9-5 java程序国际化的实现 9-6 Random类和Math类 9-7 枚举 9-8 练习题 10-1 java异常处理 10-2 认识异常 10-3 使用try和catch捕获异常 10-4 使用throw和throws引发异常 10-5 finally关键字 10-6 getMessage和printStackTrace方法 10-7 异常分类 10-8 自定义异常类 10-9 练习题 11-1 Java集合框架和泛型机制 11-2 Collection接口 11-3 Set接口实现类 11-4 List接口实现类 11-5 Map接口 11-6 Collections类 11-7 泛型概述 11-8 练习题 12-1 多线程 12-2 线程的生命周期 12-3 线程的调度和优先级 12-4 线程的同步 12-5 集合类的同步问题 12-6 用Timer类调度任务 12-7 练习题 13-1 Java IO 13-2 Java IO原理 13-3 流类的结构 13-4 文件流 13-5 缓冲流 13-6 转换流 13-7 数据流 13-8 打印流 13-9 对象流 13-10 随机存取文件流 13-11 zip文件流 13-12 练习题 14-1 图形用户界面设计 14-2 事件处理机制 14-3 AWT常用组件 14-4 swing简介 14-5 可视化开发swing组件 14-6 声音的播放和处理 14-7 2D图形的绘制 14-8 练习题 15-1 反射 15-2 使用Java反射机制 15-3 反射与动态代理 15-4 练习题 16-1 Java标注 16-2 JDK内置的基本标注类型 16-3 自定义标注类型 16-4 对标注进行标注 16-5 利用反射获取标注信息 16-6 练习题 17-1 顶目实战1-单机版五子棋游戏 17-2 总体设计 17-3 代码实现 17-4 程序的运行与发布 17-5 手动生成可执行JAR文件 17-6 练习题 18-1 Java数据库编程 18-2 JDBC类和接口 18-3 JDBC操作SQL 18-4 JDBC基本示例 18-5 JDBC应用示例 18-6 练习题 19-1 。。。
算法笔记-泛型算法题.md
07-07
泛型算法.md
java基于J2ME的游戏开发——贪吃蛇论文.docx
08-09
"本文主要探讨了使用Java 2 Micro Edition (J2ME) 技术在手机上开发贪吃蛇游戏的过程。通过JDK 1.6和NetBeans 5.5开发环境，以及WTK 2.5模拟器进行测试，实现了经典游戏在移动设备上的移植，旨在满足用户对手机游戏...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值