5 07, 2007
---- 我们在网页设计过程中，有时为了模拟单色VGA 的显示效果或为了进行某种形象的夸张设计，而将彩色图形画面变为黑白显示，这就需要使用彩色到黑白的灰度变换技术。---- 灰度变换的算法其实很简单，只要提取每个象素点的红、绿、蓝三原色，然后根据公式：灰度值= 红色亮度值*30%+绿色亮度值*59%+蓝色亮度值*11%，计算出一个灰度值，并将其作为红，绿，蓝三原色的新值重新写回显存即可。
---- 具体步骤如下：
---- 一，调用Graphics 对象的drawImage() 方法，在applet 中显示出一幅名为 TEST.JPG 的彩色图象，drawImage() 的调用形式为： g.drawImage(name,x,y, width,heigth,this)。
---- 二，定义一个数组存放这幅彩色图像的RGB 值，数组大小就是图像的象素个数。使用PixelGrabber()获取每个象素点的RGB值。
---- 三，使用灰度变换公式计算出每个象素点的灰度值，并将其作为新的RGB 值存放回数组中，再调用createImage()方法构造出新的黑白图象。
---- 四，显示出该黑白图片。为了防止变换过程中的闪烁现象，程序中还使用了双缓冲技术，即先在虚屏中画好图象，再一次性的显示出来。
---- 程序中使用鼠标来控制彩色到黑白的变换。
---- 灰度变换的tt4.java源程序如下所示：
import java.applet.*;
import java.awt.*;
import java.awt.image.*;
public class tt4 extends Applet
{
Image art,Buf;
int onced=0;
boolean is_color=true;
Graphics Bufg;//使用双缓冲区技术抑制闪烁；
Dimension xy=null;
public void init()
{ art=getImage(getDocumentBase(),"test.jpg");
resize(640, 480);//装入图片；
}
public void paint(Graphics g)
{ if (onced==0)
//如果是第一次装入图片，则直接显示；
{ g.drawImage(art,0,0,this);
}
if ((onced==1)||(onced==2))
//如果正在进行灰度变换，则提示等待；
{ g.setColor(new Color(255,200,0));
g.drawString("running!", 1, 30);
}
if (onced==3)
//如果灰度变换完毕，则显示结果；
{ if (is_color) g.drawImage(Buf,0,0,this);
else g.drawImage(art,0,0,this);
is_color=!is_color;//在彩色与黑白之间变化；
}
}
public boolean mouseDown(Event evt, int x, int y)
{ if (onced==0)
{ onced=1;
}
repaint();//用鼠标触发事件；
return true;
}
public boolean mouseUp(Event evt, int x, int y)
{ if (onced==1)
{ onced=2;
int wd=art.getWidth(this); //取得图片宽；
int ht=art.getHeight(this);//取得图片高；
GetPixels(art,0,0,wd,ht);//调用灰度变换方法；
}
return true;
}
public void GetPixels(Image img,int x,int y,int w,int h)
{ int[]pixels=newint[w*h];
//定义一块内存空间；
int gray;
PixelGrabber pg=new PixelGrabber(img,x,y,w,h,pixels,0,w);
try{pg.grabPixels();
}
catch(InterruptedExceptione)
{System.err.println("interrupted waiting for pixels!");
return;
}
for(intj=0;j> 16)&0xff)*0.3);
gray+=(int)(((pixels[w*j+i]>>8)&0xff)*0.59);
gray+=(int)(((pixels[w*j+i] )&0xff)*0.11);
//由红，绿，蓝值得到灰度值；
pixels[w*j+i]=(255<<24)|(gray<<16)|(gray<<8)|gray;
}
}
Image pic=createImage(new MemoryImageSource(w,h,pixels,0,w));
Bufg.drawImage(pic,0,0,this); //显示黑白图片；
onced=3;
repaint();
}
public void update(Graphics g)
{ if(xy==null)
{ xy=this.size();
Buf=createImage(xy.width,xy.height);
Bufg=Buf.getGraphics();
}
paint(g);//修改update方法，避免闪烁；
}
}
---- 将源程序编译后得到tt4.class文件，利用Java Applet Wizard自动生成的 HTML文件(tt4.html) ，就可在浏览器中欣赏它的效果了。
---- 包含applet的HTML文件如下所示：
< html >
< head >
< title >对彩色图片进行灰度变换< /title >
< /head >
< body >
< p align="center" >< applet
code=tt4.class
name=tt4
width=250
height=188 >
< /applet >
< /body >
< /html >
---- 其中参数width 和height就是待变换图片的宽与高。如果要更换图片，请将待换图片改名为test.jpg。
---- 运行时，单击鼠标左键就可将彩色图片变换成黑白图片，再单击一下鼠标左键又可还原为彩色图象。本程序在Windows95、Visual J++1.1、IE4.0 环境下运行通过。
5 07, 2007
电影和电视的画面可以理解为一种动画显示，它们一般以每秒24帧的速度显示图象，利用人眼的暂停效应，产生一个连续的动作显示过程。因此，动画的本质是运动的图形，只要动画的速度(帧速度)足够快，则分散的的静态图形就会合并为一个连续运动的流程。Java动画的实现，首先用Java.awt包中Graphics类的drawImage()方法在屏幕画出图象，然后通过定义一个线程，让该线程睡眠一段时间，到时后再切换成另外一幅图象，如此循环，从而达到显示动画的目的。
1 有关概念、类及方法
1.1 线程
Java的重要特性之一是其支持多线程的程序设计。在传统的程序设计中，要执行多任务是通过定时器中断等方法，定时监控多个任务的执行情况，采用任务中断切换的方式来轮换执行各个任务，从而达到多任务并发目的。这种方法一方面消耗了大量的内存空间和cpu资源，另一方面会带来系统安全性的问题。而线程作为程序的一个执行流，在某一瞬间可被看成计算过程的一种状态，它比进程更小，并发程度更高，因此也称为轻进程。线程是cpu调度的基本单元，而进程是资源分配的基本单元，线程的引入可以提高系统的吞吐量、提高任务之间的通讯效率、有效利用系统资源。
?线程的创建
线程创建有两种方法，一种是用new产生一个Thread类对象，另外一种方法是实现Runnable接口。在需要实现多继承，并且又要建立多线程时，只能采用Runnable接口方法。我们这里采用第一种方法:
ThreadName=new Thread
?sleep(long)
让线程睡眠一定时间不动作，参数单位为千分之一秒。
?suspend()
挂起线程，暂停其执行。
?resume()
唤醒挂起的线程。
1.2 ToolKit类
它提供了AWT与平台相关类和无关类之间的链接，提供了几种方法来访问与设备相关的一些特征。如从URL或本地系统中检索图象、获取屏幕的显示特征等。在程序中定义一个ToolKit类:ToolKit=getToolKit();
1.3 MediaTracker类
提供了管理图象文件加载的能力。方法StatusID(int id,boolean load)的作用是检测加载图象文件的状态(ABORTED,COMPLETE,ERRORED,LOADING)，当检测到状态为COMPLETE时，说明图象加载完成。
2 文字动画
文字动画的实现程序比较简单，首先，用new方法创建一个新进程，用drawString()方法在屏幕显示相应文字，然后让进程睡眠一定时间，时间到后，改变文字显示位置，再重显文字。其中包含一个边界判断，重设坐标的过程，如此往复实现文字动画。程序运行后，在屏幕中央显示"欢迎进入动画世界!"，每隔0.15秒向左移动一次，直到屏幕最左端又重新开始显示。具体程序见程序1(Applet小程序)。
3 图象动画
图象动画的实现方法与文字相似，只不过定义了一个Image数组，运用getImage()方法装载相应图象文件到该数组中。程序运行后，可见到一个可爱的小精灵在作抛球动作。另外，基于程序交互性的考虑，增加了两个事件的响应动作，一个是WINDOW_DESTROY，即关闭运行窗口，正常返回。另外一个是MOUSE_DOWN，当鼠标左按钮按下时，暂停线程以便让画面静止，再按一次左按钮，恢复暂停线程，继续显示下一幅画面。
如果将程序中的小精灵图象文件换成图片，并增加延迟时间，则可以实现图片的自动切换，变为自动浏览图片程序，源程序见程序2，
4 动画质量的改善
上一程序的运行后，我们发现了两个问题。第一是程序在图象完全加载之前就开始显示，出现切换过快现象。第二是画面闪烁。
对于前一个问题，可以用Java.awt包中的MediaTracker类来解决，当StatusID()方法返回值为COMPLETE时，说明所有的图象文件加载完毕，此时才开始显示画面。
第二个问题，解决起来要复杂一些。闪烁产生的原因是，在paint()方法中如果计算较为复杂，计算和绘制画面的时间超过了屏幕的刷新周期，则帧的第一部分在一个刷新周期中绘制，其余部分在下一个、甚至更后的周期绘制，这样，在帧的不同部分之间产生时间间隔，由此造成闪烁。解决途径之一是重载update()方法，update()的缺省实现是清除原来背景，然后调用paint()方法。因此通过重载update()，只有在必要时才清除整个背景。
解决途径之二是采用双缓冲技术，双缓冲技术是在后台图形区内创建一个图形对象，将需要绘制的图象绘于其上，然后传给paint()方法，由paint()方法绘于前台，同时，后台图形缓冲区进入下一帧图象的准备。图1为双缓冲技术示意图。
5 07, 2007
笔者在这里将画线,画或填充多边形等理解为"图形"技术,将图片的变换,显示理解为"图像"技术.相对而言,图形技术较简单,图像技术较复杂.下面笔者从实用的角度出发,讲解几个图像编程问题.首先,我们看下面这个程序.
import java.applet.*;
import java.awt.*;
public class easy extends Applet
{
int i=1;
Image img;
public void init()
{
img=getImage(getCodeBase(),"mama.gif");
}
public void paint(Graphics g)
{
g.drawImage(img,0,0,this);
showStatus(String.valueOf(i++));
}
}
HTML 文件如下:
<APPLET CODE="easy.class"WIDTH=300 HEIGHT=300></APPLET>
程序非常简单. 但你注意到没有,在浏览器的状态栏,显示出的数值并不一定是1: 你要显示的图片幅面越大,这个数值越大.这说明 paint() 方法被调用了不止一次.那么，是谁,在什么时候调用的?
事实上,每当有新的图片数据到达或生成时,Java小程序都会自动去调用paint()方法重绘屏幕.这个工作由ImageObserver接口的imageUpdate()方法实现.你可以超越这个imageUpdate()方法,自己重新编程.考虑到本地的机器从Web服务器上获取图片的速度一般比较慢,很多时候你必须要知道已经有多少图片数据已经被下载.下面给出一个示范程序,程序可以一边下载,一边显示,同时通知用户已经获得多少图片数据.
import java.awt.*;
import java.applet.*;
import java.awt.image.*;
public class image_download extends Applet
{
Image img;
int step=0;//step 用来表述已被下载的那部分图片的高度
int percent=0;//percent 用来表述已下载的图片的高度占图片总高度的百分比
public void init()
{
img=getImage(getCodeBase(),"mama.gif");
}
public void paint(Graphics g)
{
g.drawImage(img,0,0,this);
}
//下面我们超越本来的imageUpdate()方法.每当有新的图片数据到达(或产生)时此方法会被自动调用
public boolean imageUpdate(Image img_ob,int flags,int x,int y,int width,int height)
{
if(((flags & SOMEBITS)!=0) & (img_ob==img))//判断是否又有新的图像数据都被下载
{
step=step+height;//计算已被下载的图片的高度
percent=step*100/img.getHeight(this);//计算这个高度占图片高度的的百分比
showStatus(percent+"%");//在状态栏显示
repaint(x,y,width,height);//重绘屏幕.但只画新数据表达的部分.简单使用repaint()重绘
//整个屏幕会使画面闪烁
}
if((flags & ERROR)!=0)//假如下载出错
showStatus("image loading error");
if((flags & ALLBITS)!=0)//假如全部图片数据都已下载完
showStatus("Done");
return true;
}
}
HTML文件如下:
<APPLET CODE="image_download.class"WIDTH=300 HEIGHT=300></APPLET>
imageUpdate()参数说明如下:
img_ob: 被监视的图像.
flags: 被监视图像的状态.
ABORT: 图像生成被异常中断
ALLBITS: 全部图像都已生成
ERROR: 发生错误
FRAMEBITS: 完成一幅
HEIGHT: 本次生成的高度
SOMEBITS: 已将生成了一部分图像
WIDTH: 本次生成的宽度
x: x轴坐标
y: y轴坐标
width: 本次下载的图像的宽度
height: 本次下载的图像的高度
下面用两个例子说明怎样获取大幅图像的局部.第一个例子使用CropImageFilter类去获得图像的局部.你可以这样使用这种技术:
首先根据图像裁剪过滤器产生图像过滤器.
ImageFilter filter=new CropImageFilter (int x, int y, int width, int height).
x: 裁剪起始点 X 轴坐标
y: 裁剪起始点Y 轴坐标
width: 裁剪宽度
height: 裁剪高度
然后根据根据过滤器产生图像生产者. ImageProducer procuder=new FilteredImageSource(baseImage.getSource(),filter).
baseImage: 将要被裁剪的图片
然后根据图像生产者产生新的图像. Image img=createImage(procuder).
下面的程序使用上述技术裁剪图片.程序运行后,你用"拖拽"鼠标的方式(按住鼠标键并移动鼠标)在图片上选定一片区域,然后再在运行区上点击鼠标,刚才你选定的区域的图片将被复制到这个位置.要注意的是,程序并未对选择区域的起始点和终止点的相对位置作出判断,因此,你一定要使终止点在起始点的右下方.
import java.awt.*;
import java.applet.*;
import java.awt.image.*;
public class CropFilterImage extends Applet
{
Image baseImage,cropImage;//baseImage是原始图片,cropImage是根据选定区域产生的新图片
int sx,sy;//选定区域起始点坐标
int dx=0,dy=0;//要显示新图片的位置
int width,height;//选定区域的宽和高
boolean selected=false;//用来判定现在用户在干什么
public void init()
{
baseImage=getImage(getCodeBase(),"mama.gif");
cropImage=baseImage;
}
public void paint(Graphics g)
{
g.drawImage(baseImage,0,0,this);
g.drawImage(cropImage,dx,dy,this);
}
public boolean mouseDown(Event evt,int x,int y)
{
if(!selected)//假如用户开始选择
{
sx=x;//记下起始点
sy=y;
selected=true;
return true;
}
else//假如用户已经设定了选择区
{
dx=x;
dy=y;
cropImage=cropImage();//裁剪图像
repaint();//重画屏幕
selected=false;
}
return true;
}
public boolean mouseUp(Event evt,int x,int y)
{
if(selected)//用户松开鼠标健表示已确定选择区
{
width=Math.abs(x-sx);
height=Math.abs(y-sy);
getGraphics().drawRect(sx,sy,width,height);
}
return true;
}
public boolean mouseDrag(Event evt,int x,int y)
{
showStatus("from("+sx+","+sy+") to ("+x+","+y+")");
return true;
}
Image cropImage()
{
ImageFilter filter=new CropImageFilter(sx,sy,width,height);//根据图像裁剪过滤器产生过滤器
//下面根据过滤器产生图像生产者
ImageProducer producer=new FilteredImageSource(baseImage.getSource(),filter);
Image img=createImage(producer);//根据图像生产者产生新图像
return img;
}
}
HTML文件如下:
<APPLET CODE="CropFilterImage.class"WIDTH=600 HEIGHT=300></APPLET>
很多情况下上面的方法不实用.比如你想对图片作出某种变换,上面的方法就无能为力了.下面的程序给出更强大的算法:将图像数据取到数组中,再在数组中将需要的数据提取出来,依据这些数据再生成新的图像去显示.设想你有一个幅面大于窗口尺寸的图像要显示,你必须要让用户可以控制窗口的位置,通过移动窗口,浏览
整个图像.程序运行后,你可以用四个光标键移动窗口浏览全部图像.
程序中的关键技术有三个,第一个是PixelGrabber类用于获取图像数据.你可以这样使用:
首先生成一个PixelGrabber实例:
PixelGrabber pg=new PixelGrabber(Image img,int x,int y,int width,int height,int pix[ ],int offset,int scansize)
img: 被取数据的图像
x: 起始点 x 轴坐标
y: 起始点 y 轴坐标
width: 图像宽度
height: 图像高度
pix[ ]: 目标数组
offset: 目标数组的起始地址
scansize: 图像每行点数
然后使用grabPixels( ) 方法取数据:
try { pg.grabPixels( ) ; }
catch ( InterruptedException e) { }
第二个关键技术是使用媒体追踪器MediaTracker监视图像的生成情况.你可以这样使用:
首先生成一个媒体追踪器的实例:
MediaTracker mt=new MediaTracker(this);
然后向其中加入要追踪的图像:
mt.addImage(Image image,int ID)
image是你要追踪的图像, ID是你设定的一个表示这个图像的序号.
然后使用waitForID ( int ID ) 或 waitForAll( ) 等待图像全部生成
try { mt.waitForID(1);}
catch(InterruptedException e){ }
第三个关键技术是使用内存数据(数组)产生图像.你可以这样使用:
createImage(new MemoryImageSource(int width, int height, int pix[ ], int offset, int scanwidth)
width: 欲生成的图像的宽度
heidth: 欲生成的图像的高度
pix[ ]: 数据源
offset: 丛数组的哪里开始使用数据
scanwidth: 图像每行的象素数
程序如下:
import java.applet.*;
import java.awt.*;
import java.awt.image.*;
public class picture_window extends Applet
{
Image img_full,img_window;//img_full是原图像, img_window是从原图像中裁剪的要在窗口中显示的图像
int img_width,img_height;//原始图像的宽和高
int window_width=150,window_height=150;//窗口的宽和高
int window_x=30,window_y=30;//窗口的左上角坐标
int point_img_full,point_img_window;//原始图像数据数组的操作地址和窗口图像数据数组的操作地址
int img_full_data[];//原始图像数据数组.没有初始化是因为现在不知道原始图像的大小
int img_window_data[]=new int[window_width * window_height];//窗口图像数据数组
MediaTracker mt=new MediaTracker(this);//媒体追踪器
PixelGrabber img_full_grabber;//用来获取原始图像的数据
public void init()
{
img_window=createImage(window_width,window_height);//创建窗口图像
img_full=getImage(getCodeBase(),"mama.gif");
//下面要等待直到全部的原始图像数据都被正确载入.否则无法知道原始图像的大小
mt.addImage(img_full,1);//向媒体追踪其中加入要追踪的图像
try{mt.waitForID(1);} // 等待全部数据被正确载入
catch(InterruptedException e){ }
img_width=img_full.getWidth(this);//现在可以获取原始图像的正确信息了.取它的宽和高
img_height=img_full.getHeight(this);
img_full_data=new int[img_width * img_height];//初始化原始图像数据数组
img_full_grabber=new PixelGrabber(img_full,0,0,img_width,img_height,img_full_data,0,img_width);//准备获取图像数据
try{img_full_grabber.grabPixels();}//采集数据
catch(InterruptedException e){ }
get_img_window_data();//生成窗口图像
}
public void paint(Graphics g)
{
g.drawImage(img_window,0,0,this);
}
public void get_img_window_data()
{
point_img_full=window_y * img_width+window_x;//从这个位置开始获取原始图像数据
point_img_window=0;//从这个位置开始向窗口图像数据数组放数据
for(int i=0;i<window_height;i++)//逐行处理
{
for(int j=0;j<window_width;j++)//逐列处理
img_window_data[point_img_window++]=img_full_data[point_img_full++];//取和存
point_img_full=point_img_full+img_width-window_width;//开始处理下一行
}
img_window=createImage(new MemoryImageSource(window_width,window_height,img_window_data,0,window_width));//根据内存数据(数组)生成图像
//等待图像完全生成.否则一边生成一边绘制窗口图像会闪烁.
mt.addImage(img_window,1);
try{mt.waitForID(1);}
catch(InterruptedException e){}
}
//下面的键盘事件方法根据用户的按键重置窗口坐标,再生成图像,再显示
public boolean keyDown(Event e,int key)
{
switch(key)
{
case(Event.UP):
if(window_y>0)
window_y-=1;
break;
case(Event.DOWN):
if(window_y<(img_height-window_height))
window_y+=1;
break;
case(Event.RIGHT):
if(window_x<(img_width-window_width))
window_x+=1;
break;
case(Event.LEFT):
if(window_x>0)
window_x-=1;
break;
default:
break;
}
showStatus(String.valueOf(window_x)+" , "+String.valueOf(window_y));
get_img_window_data();
getGraphics().drawImage(img_window,0,0,this);
return true;
}
}
HTML文件如下:
<APPLET CODE="picture_window.class"WIDTH=150 HEIGHT=150></APPLET>
下面的程序对两个图像进行合成并显示来模拟图像的淡入淡出.程序运行后,每按一次向上键,前景图像就增强一点,每按一次向下键,前景图像就减弱一点.
首先你要了解图像数据.
每个象素点的信息由一个整数表达.整数共32个二进制位,从左向右,分成四个部分,每部分都是8位.
第一部分: Alpha 信息.控制图像显示的强度.下面的程序就是通过调整这个数值控制图像的淡入淡出.
第二部分:红色数据.
第三部分:绿色数据.
第四部分:蓝色数据.
程序使用的方法是:先画背景图像,再在上面画带Alpha数据的前景图像,通过调整Alpha值使前景图像淡入 淡出.
import java.applet.*;
import java.awt.*;
import java.awt.image.*;
public class alpha extends Applet
{
Image background, foreground;//背景图像和前景图像
Image foreground_new;//依据前景图像生成的带Alpha通道的新图像
MediaTracker mt;
int foreground_alpha=175;//前景图像的起始Alpha值
int foreground_data[];//用来生成新图像的内存数据
PixelGrabber pg;
int transparancy;//前景图像的全透明点的像素值.只要前景图像的某个点是这个值,它就全透明
public void init()
{
background=getImage(getCodeBase(),"mama.gif");
foreground=getImage(getCodeBase(),"baba.gif");
mt=new MediaTracker(this);
mt.addImage(background,1);
mt.addImage(foreground,2);
try{mt.waitForAll();} // 等待所有图片的数据都被正确载入
catch(InterruptedException e){ }
foreground_data=new int[foreground.getWidth(this) * foreground.getHeight(this)];//初始化
//下面把前景图片的数据载入数组
pg=new PixelGrabber(foreground,0,0,foreground.getWidth(this),foreground.getHeight(this),foreground_data,0,foreground.getWidth(this));
try{pg.grabPixels();}
catch(InterruptedException e){ }
for (int i=0;i<(foreground.getWidth(this) * foreground.getHeight(this));i++)
foreground_data[i]=foreground_data[i]&0x00ffffff;//把所有的象素的Alpha值置为0
//下面我把图像左上角的点的值作为透明值.假如图像中哪个点的值和左上角的点的值一样,
//这个点就全透明--背景100%出现.我用这个比较简单的办法把前景图像中我不想要的部分去掉
transparancy=foreground_data[0];
}
public void paint(Graphics g)
{
g.drawImage(background,0,0,this);
}
public boolean keyDown(Event e, int key)
{
if (key==Event.UP && foreground_alpha<255)//依据按键改变Alpha值
foreground_alpha++;
if (key==Event.DOWN && foreground_alpha>0)
foreground_alpha--;
showStatus(String.valueOf(foreground_alpha));//在状态栏显示Alpha值
for (int i=0;i<(foreground.getWidth(this) * foreground.getHeight(this));i++)//逐点处理
{
foreground_data[i]=foreground_data[i] & 0x00ffffff;//置此点为全透明
if (foreground_data[i]!=transparancy)//假如这个点的值和全透明点不同
foreground_data[i]=foreground_data[i] | (foreground_alpha<<24);//给它Alpha值
}
foreground_new=createImage(new MemoryImageSource(foreground.getWidth(this),foreground.getHeight(this),foreground_data,0,foreground.getWidth(this)));//生成前景图象
mt.addImage(foreground_new,3);
try{mt.waitForID(3);}
catch(InterruptedException e2){ }
getGraphics().drawImage(background,0,0,this);//先画背景
getGraphics().drawImage(foreground_new,100,100,this);//再画前景
return true;
}
}
下面是HTML文件:
<APPLET CODE="alpha.class"WIDTH=300 HEIGHT=300></APPLET>
5 07, 2007
本章主要讨论Cache和Preload---图片的预先调用。为什么要对图片进行预先的调用？答案非常简单：为了速度。
你是否已经注意到了，一个以前曾经访问过的页面再次进入时速度会比以前快许多？这是因为页面中所有的图片都已经被“cached”了。
对于IE，在windows目录下的Temporary Internet Files的子目录内，对于 Netscape则是在一个叫做cache的子目录中，保存这你曾经浏览过的一些页面的HTML文档和图片。当你第一次浏览页面时这些资料写入cache以备今后的需要。下一次再光临时，则直接从硬盘的cache中读取资料，速度当然快多了。
下面的内容就跟javascript扯上关系了。
（1）并非所有的cache都是有利的，因为有时候你需要频繁地更新页面，或者再页面上放置了一些诸如计数器之类的动态脚本，你需要浏览时及时更新这些资料，并非从cache中读取旧的数据。那么，用下面的方法可以将页面cache屏蔽起来。
将如下代码加入HTML的<head>区即可。
<META HTTP-EQUIV="Pragma" CONTENT="no-cache">
（2）为了加快下载速度，可以将一些可能要使用的图片预先读取出来，那么当使用的时候就不必现下载了。尤其是制作onmouseover效果（例如：鼠标移动到一个按钮上产生按下或变色等效果）时，否则会有明显的延迟，效果就大打折扣了。
（3）预先读取图片的方法是比较简单的，用javascript这样实现。
将如下的类似代码放在HTML的<head>区：
<SCRIPT LANGUAGE="JavaScript">
<!--
Image1= new Image(100,50)
Image1.src = "image1.gif"
Image2 = new Image(100,50)
Image2.src = "image2.gif"
Image3 = new Image(100,50)
Image3.src = "image3.gif"
// -->
</SCRIPT>
这样浏览器在装载页面时就已经预先下载了3个图片（image1.gif,images2.gif和image3.gif）。当激发onmouseover事件时，浏览器直接从Cache中读取图片，速度当然快多了。
这里做一些小小说明：图片的名字可以是任意的，100和50分别是读入cache的图片的宽度和高度。但是脚本格式必须按照规定的格式写，"Image1=new Image"。如果图片在其它服务器的子目录内，只要用正确的绝对路径表示即可。
脚本可以放在HTML的任意位置，但是建议放在靠上的位置，在<head>区是最好的，因为它能保证最先被读取。
将需要预先被读取的所有图片都加入代码中，按格式写就可以了。
5 07, 2007
Java从网络上获取声音文件并播放声音的编程方法有两类，一是利用Java提供的play(URL)及play(URL,String) 直接播放网络上的声音文件，另一类是通过getAudioClip(URL)或getAudioClip(URL,String)先从网络上获取声音文件，并生成AudioClip 类型的对象，然后对该对象进行操作。前者的使用格式是：
String Audur = "结点URL";
try {
play(new URL(Audur));
} catch(Exception e){}
或
String Audur = "结点URL";
try {
play(new URL(Audur),声音文件名);
} catch(Exception e){}
后者使用的格式是：
String Audur = "结点URL";
AudioClip loopClip;
try {
loopClip = getAudioClip(new URL(Audur));
}
catch(Exception e){
System.out.println("Can´t open the URL ");
}
或
String Audur = "结点URL";
AudioClip loopClip;
try {
loopClip = getAudioClip(new URL(Audur) ,声音文件名);
}
catch(Exception e){
System.out.println("Can´t open the URL ");
}
上面的四种格式都是将生成URL对象部分－－“new URL(url)”
直接作为play或getAudioClip的参数；和前面处理图象的例子一样，
也可以先用“new URL(url)”获取一个URL对象， 再传给 play 或
getAudioClip。如对第一种play(URL)的格式， 也可采用如下的编
程格式：
URL Audur =null;
try {
Audur=new URL("结点URL ");
} catch(Exception e){
System.out.println("Can´t open the URL ");
}
play(Audur);
下面对前述四种从网络上获取并播放声音文件的格式各举一简单的例子，
以作编程时参考：
●程序4 格式一
import java.applet.*;
import java.awt.*;
import java.net.*;
public class sound1 extends Applet
{ AudioClip loopClip;
public void paint(Graphics g) {
String Audur = "http://www.shu.edu.cn/~xyx/java/Animator/audio/bark.au";
try {
play(new URL(Audur));
} catch(Exception e){}
}
}
●程序5 格式二
import java.applet.*;
import java.awt.*;
import java.net.*;
public class sound2 extends Applet
{ AudioClip loopClip;
public void paint(Graphics g) {
String Audur = "http://www.shu.edu.cn/~xyx/java/Animator/audio/";
try {
play(new URL(Audur),"bark.au");
} catch(Exception e){}
}
}
●程序6 格式三
import java.applet.*;
import java.awt.*;
import java.net.*;
public class sound extends Applet{
AudioClip loopClip;
public void init() {
String Audur = "http://www.shu.edu.cn/~xyx/java/Animator/audio/bark.au";
try {
loopClip = getAudioClip(new URL(Audur));
} catch(Exception e){}
}
public void paint(Graphics g){
loopClip.loop();
}
}
●程序7 格式四
import java.applet.*;
import java.awt.*;
import java.net.*;
public class sound0 extends Applet{
AudioClip loopClip;
URL auur;
public void init() {
try {
auur=new URL("http://www.shu.edu.cn/~xyx/java/Animator/audio/");
}
catch (MalformedURLException e) {
System.out.println("Can´t open the URL ");
}
loopClip = getAudioClip(auur,"bark.au");
}
public void paint(Graphics g){
loopClip.loop();
}
}
5 07, 2007
与其它语言相比较，如果说Java对图形和文本媒体的支持并不占明显优势的话，那么Java对图像与声音媒体的支持真可谓是技高一筹，显示图像与播放声音就如同显示一行文
本一样方便。同时，正由于在Java动画中灵活的运用图像和声音媒体，才使得Web页面更
具魅力。
4.2.1 图像文件的显示
正如上一节所介绍的，Graphics类中确实提供了不少绘制图形的方法，但如果用它们
在applet运行过程中实时地绘制一幅较复杂的图形（例如一条活泼可爱的小狗），就好比
是在用斧头和木块去制造航天飞机。因此，对于复杂图形，大部分都事先用专用的绘图软
件绘制好，或者是用其它截取图像的工具（如扫描仪、视效卡等）获取图像的数据信息，
再将它们按一定的格式存入图像文件。applet运行时，只要找到图像文件存贮的位置，将
它装载到内存里，然后在适当的时机将它显示在屏幕上就可以了。
1. 图像文件的装载
Java目前所支持的图像文件格式只有两种，它们分别是GIF和JPEG格式（带有.GIF、
.JPG、.JPEG后缀名的文件）。因此若是其它格式的图像文件，就先要将它们转换为这两
种格式。能转换图像格式的软件有很多，如PhotoStyler等。
Applet类中提供了getImage( )方法用来将准备好的图像文件装载到applet中，但我
们必须首先指明图像文件所存贮的位置。由于Java语言是面向网络应用的，因此文件的存
贮位置并不局限于本地机器的磁盘目录，而大部分情况是直接存取网络中Web服务器上的
图像文件，因而，Java采用URL（Universal Resource Location，统一资源定位器）来定
位图像文件的网络位置。因此，Java专门提供了URL类来管理URL信息（关于该类的详细介
绍见下一章）。
表示一个URL信息可分为两种形式：
一种称为绝对URL形式，它指明了网络资源的全路径名。如：
绝对URL：“http://www.xyz.com/java/imgsample/images/m1.gif”
另一种称为相对URL形式，分别由基准URL（即base URL）再加上相对于基准URL下的
相对URL这两部分组成，例如上面的例子可表示为：
基准URL：“http://www.xyz.com/java/imgsample/”
相对URL：“images/m1.gif”
现在，我们可以来看一下getImage( )方法的调用格式了：
Image getImage(URL url)
Image getImage(URL url, String name)
我们可以发现，这两种调用格式的返回值都是Image对象。确实，Java特别提供了
java.awt.Image类来管理与图像文件有关的信息，因此执行与图像文件有关的操作时不要
忘了import这个类。getImage( )方法的第一种调用格式只需一个URL对象作为参数，这便
是绝对URL。而后一种格式则带有两个参数，第一个参数给出的URL对象是基准URL，第二
个参数是字符串类型，它描述了相对于基准URL下的路径和文件名信息，因此这两个参数
的内容综合在一起就构成了一个绝对URL。例如，下面两种写法所返回的结果是一样的：
Image img=getImage(new URL("http://www.xyz.com/java/imgsample/images/m1.gif");
Image img=getImage(new URL("http://www.xyz.com/java/imgsample/"),"images/m1.gif");
表面看来，好象第一种调用格式较方便一些，但实际上第二种调用格式用得更普遍，
因为这种格式更具灵活性。原来，Applet类中提供了两个方法来帮助我们方便地获取基准
URL对象，它们的调用格式如下：
URL getDocumentBase( )
URL getCodeBase( )
其中getDocumentBase( )方法返回的基准URL对象代表了包含该applet的HTML文件所
处的目录，例如该文件存贮在"http://www.xyz.com/java/imgsample/m1.html"中，则该
方法就返回"http://www.xyz.com/java/imgsample/"路径。而getCodeBase( )方法返回的
基准URL对象代表了该applet文件(.class文件)所处的目录。它是根据HTML文件的"APPLET"
标记中的CODEBASE属性值计算出来的，若该属性没有设置，则同样返回该HTML文件所处的
目录。
好了，现在我们应该可以感受到基准URL的灵活性了吧。只要我们写下语句：
Image img = getImage(getDocumentBase( ),"images/m1.gif");
那么即使整个imgsample目录移到别处任何地方，也可以正确装载图像文件，而采用
对于绝对URL形式则需要重新修改applet代码并重新编译。
2. 图像文件的显示
getImage( )方法仅仅是将图像文件从网络上装载进来，交由Image对象管理。那我们
怎样把得到的Image对象中的图像显示在屏幕上呢？这又要回到我们的老朋友Graphics类
中来了，因为Graphics类提供了一个drawImage( )方法，它能完成将Image对象中的图像
显示在屏幕的特定位置上，就象显示文本一样方便。drawImage( )方法的调用格式如下：
boolean drawImage(Image img, int x, int y, ImageObserver observer)
其中img参数就是要显示的Image对象。x和y参数是该图像左上角的坐标值。observer
参数则是一个ImageObserver接口（interface），它用来跟踪图像文件装载是否已经完成
的情况，通常我们都将该参数置为this，即传递本对象的引用去实现这个接口。
除了将图像文件照原样输出以外，drawImage( )方法的另外一种调用格式还能指定图
像显示的区域大小：
boolean drawImage(Image img, int x, int y, int width, int height, ImageObserver observer)
这种格式比第一种格式多了两个参数width和height，即表示图像显示的宽度和高度
。若实际图像的宽度和高度与这两个参数值不一样时，Java系统会自动将它进行缩放，以
适合我们所定的矩形区域。
有时，我们为了不使图像因缩放而变形失真，可以将原图的宽和高均按相同的比例进
行缩小或放大。那么怎样知道原图的大小呢？只需调用Image类中的两个方法就可以分别
得到原图的宽度和高度。它们的调用格式如下：
int getWidth(ImageObserver observer)
int getHeight(ImageObserver observer)
同drawImage( )方法一样，我们通常用this作为observer的参数值。
下面的程序段给出了一个显示图像文件的例子，其显示结果如图4－14所示。
import java.awt.Graphics;
import java.awt.Image;
public class Images extends java.applet.Applet{
Image img;
public void init(){
img=getImage(getCodeBase(),"man.gif");
}
public void paint(Graphics g){
int w=img.getWidth(this);
int h=img.getHeight(this);
g.drawImage(img,20,10,this); //原图
g.drawImage(img,200,10,w/2,h/2,this); //缩小一半
g.drawImage(img,20,200,w*2,h/3,this); //宽扁图
g.drawImage(img,350,10,w/2,h*2,this); //瘦高图
}
}
图4－14 显示图像文件
4.2.2 声音文件的播放
对声音媒体的直接支持可以说是Java的一大特色，尤其是在动画中配上声音效果，就
可以使人在视觉上和听觉上均得到美的享受，那才叫过瘾。Java中播放声音文件与显示图
像文件一样方便，同样只需要先将声音文件装载进来，然后播放就行了。
Java目前支持的声音文件只有一种格式，那就是SUN公司的AU格式（.AU文件），也称
为u-law格式。由于AU格式的声音仅有8KHz的采样频率且不支持立体声效果，所以音质不
算太好。唯一的好处就是AU声音文件的尺寸比其它格式小，有利于网上传输。一般，我们
较熟悉的大都是WAV格式的声音文件，因此必须先将它们转换为AU格式(可以选用Goldwave
软件来进行这种格式转换)。
声音文件准备好以后，就可以考虑将它装载进来并播放。在Applet类中提供的play( )
方法可以将声音文件的装载与播放一并完成，其调用格式如下：
void play(URL url)
void play(URL url, String name)
可见，play( )方法的调用格式与getImage( )方法是完全一样的，也采用URL来定位
声音文件。例如，某声音文件audio.au与applet文件存放在同一目录下，可以这样写：
play(getCodeBase( ),"audio.au");
一旦play( )方法装载了该声音文件，就立即播放。如果找不到指定URL下的声音文件
，play( )方法不返回出错信息，只是听不到想听的声音而已。
由于play( )方法只能将声音播放一遍，若想循环播放某声音作为背景音乐，就需要
用到功能更强大的AudioClip类，它能更有效地管理声音的播放操作。因为它被定义在
java.applet程序包中，所以使用该类的话，不要忘了在程序头部加上：
import java.applet.AudioClip;
为了得到AudioClip对象，我们可以调用Applet类中的getAudioClip( )方法。它能装
载指定URL的声音文件，并返回一个AudioClip对象，其调用格式如下：
AudioClip getAudioClip(URL url)
AudioClip getAudioClip(URL url, String name)
得到AudioClip对象以后，就可以调用AudioClip类中所提供的各种方法来操作其中的
声音数据，这些方法如表4－4所示。
如果getAudioClip( )方法没有找到所指定的声音文件，就会返回null值。所以，在
调用表4－4中所列的方法前，应该先检查一下得到的AudioClip对象不是null，因为在null
对象上调用上述方法将导致出错。
如果需要的话，我们还可以在applet中同时装载几个声音文件来一起播放，到时候，
这些声音将混合在一起，就象二重奏一样。另外还有一点要说明的是，如果我们使用
AudioClip对象的loop( )方法来重复播放背景音乐时，千万不要忘记在适当的时候调用
AudioClip对象的stop( )方法来结束放音，否则的话，即使用户离开这一Web页面，该声
音也不会停止，这无疑将会惹恼用户。因此，一般我们都在applet的stop( )方法中添上
停止播放的代码。
例如，下面这段程序将播放两段声音，一段是连续播放的背景音乐，另一段是讲话录
音。
import java.applet.AudioClip;
public class Audios extends java.applet.Applet{
AudioClip bgmusic,speak;
public void init(){
bgmusic=getAudioClip(getDocumentBase(),"space.au");
speak=getAudioClip(getDocumentBase(),"intro.au");
}
public void start(){
if(bgmusic!=null)
bgmusic.loop();
if(speak!=null)
speak.play();
}
public void stop(){
if(bgmusic!=null)
bgmusic.stop(); //关闭背景音乐，切记。
}
}
5 07, 2007
声音可以创造意境，触发遐想，当与虚拟图像相结合时，更加可以让整个世界充满幻觉。声音是多媒体技术的基础。这就是Sun公司的JAVA媒体技术开发小组忙于准备Java Sound 1.0 API并将其包含于下一版本的JAVA开发工具库中的原因。在JAVA2平台出现之前，JAVA语言只能处理电话音质的声音，以单声道8KHZ的采样频率存储为μ-law AU文件。JAVA2平台增加了对AIFF，WAV以及三种MIDI文件类型的支持。所支持的三种MIDI文件格式为MIDI文件类型0、MIDI文件类型1、以及RMF。
应用程序接口API1.0版提供了一个易于使用的工具集，使程序员可以访问底层的合成与演奏引擎，从而扩展了JAVA声音的应用。其中两个重要的领域是创建数字化音频以及乐器指令数字化接口MIDI。由于提供了大量的底层支持功能，所以程序员能输入输出声音，控制MIDI设备，并能查询系统运作情况。
声音文件类型简介
主要的声音文件类型如下：
AU - (扩展名为AU或SND)适用于短的声音文件，为Solaris和下一代机器的通用文件格式，也是JAVA平台的标准的音频格式。AU类型文件使用的三种典型音频格式为: 8位μ-law类型（通常采样频率为8kHz), 8位线性类型，以及16位线性类型。
WAV - (扩展名为WAV)由 Microsoft和 IBM共同开发,对WAV的支持已经被加进Windows 95并且被延伸到Windows 98. WAV文件能存储各种格式包括μ-law,a-law和 PCM (线性)数据。他们几乎能被所有支持声音的Windows应用程序播放。
AIFF - (扩展名为AIF或IEF)音频互换文件格式是为Macintosh计算机和Silicon Graphics (SGI)计算机所共用的标准音频文件格式。AIFF和 AIFF-C几乎是相同的,除了后者支持例如μ-law和 IMA ADPCM类型的压缩。
MIDI - (扩展名为MID)乐器数字接口MIDI是为音乐制造业所认可的标准，主要用于控制诸如合成器和声卡之类的设备。
MIDI文件不包含数字音频采样，而是包括一系列指令，这些指令控制把来自不同乐器上的音符序列合成乐曲。一些MIDI文件包含附加指令来为各种合成设置进行编程。
大多数合成器支持MIDI标准，所以在一个合成器上制作的音乐能够在另一个上播放。 有 MIDI接口的计算机能操纵 MIDI数据以产生新音乐或音响效果。例如，一个完整的音乐作品可以通过一个软件驱动的命令转换成全新的形式。
JAVA声音引擎支持两种MIDI文件类型：
MIDI类型0文件-包含仅仅一个序列，所有相关的乐器部分被包含在同一个逻辑 "磁道"上。
MIDI类型1文件-包含多重的 "磁道"使得不同的乐器被逻辑地分开，从而使对声音的操作和重组更加容易。
RMF - (扩展名为RMF)混合音乐格式是由Beatnik设计出来的混合文件类型，通过交互式设定将MIDI和音频采样封装在一起。RMF好比是一个所有音乐相关文件的容器。RMF也包含对有关版权的详细文件说明的支持。RMF文件可以包含多个由不同艺术家创作的存储为MIDI类型或音频采样类型的作品,每个都关联着相关的版权信息。
对声音引擎的选择
在1997年,SUN的JAVA媒体开发组试图找到一种方法，以增强声音的处理能力并为将来提供一个坚实的平台。根据JAVA媒体开发组经理Michael Bundschuh所说,
"我们想要非常高质量的播放引擎以处理所有的从八位μ-law级直到 CD质量声音的每一件操作。 我们希望轻松跨越所有平台，诸如Solaris平台, Windows, Mac以及其他。我们也想要高度发展了的能够跨越不同平台的MIDI能力。为上述目的，合理的选择是Beatnik的音频引擎(从前是Headspace。)"
SUN取得了Beatnik的音频引擎使用许可，把它当作JAVA声音应用程序接口API的基础。
Thomas Dolby Robertson-Beatnik简介
在90年代初之前，Thomas Dolby Robertson的职业完全在音乐方面。他1982推出的"她用科学照亮了我"是一部早期的MTV巨作。整个80年代，他都在不断地作曲和录音，使用一种非结构化音乐制作软件。但是在 1990,通过一次为Guggenheim博物馆演示虚拟现实的合作，他开始思考能否做一些提高音乐制作能力的工作。
"我当时正伏在 C程序员的肩上，并且我突然认识到为做记录做了大量的工作，可是没有为演奏时的交互做任何事情。"有了这样的想法，Robertson在1992年建立了Headspace，雇用月光作曲组来帮助实现他的观点。Headspace于1996年成为公司，现在被称为Beatnik。
JAVA声音音频引擎
JAVA声音引擎为多媒体创建，同时考虑了游戏设计和发布WEB内容。用标准的 MIDI文件、RMF文件、并且/或来自任何源的采样，该引擎将播放音乐或制造音响效果，同时尽可能少用CPU。它提供完全的播放控制，具有混合音响的能力并可实时地回应用户的输入。
JAVA声音引擎是软件 MIDI合成器,采样播放设备,以及16位立体混声器。它支持混合直到64位的立体MIDI声音和音频采样。它直接支持MIDI类型0和类型1文件以及从8位设备到16位乐器的波表合成。该引擎支持所有通用的 MIDI控制器并且包含象回声处理, LFO (控制过滤器或立体声设备)之类的特性，以及ADSR信封 (播放时整形采样)。
即使用上所有的功能，JAVA声音引擎在一个90Mhz的奔腾计算机上也占用不超过30％的CPU时间。它还能通过有选择地禁用不需要的特性，使其变得更加高效一些。另外，它发布了存储在压缩的RMF音乐文件中的丰富的内容。Thomas Dolby Robertson的"她用科学照亮了我"，一首7分21秒的歌曲，如存储为CD音质的文件足足占用70M字节空间。如果以RMF格式存储只需大约636 KB,是120:1的减少，同时丝毫不减音质。
为更多有关Beatnik的信息，请看Beatnik的WEB站点。
JAVA平台声音的简要历史
在JDK 1.0.x及JDK 1.1.x下, AudioClip接口提供下列机能：
l AudioClip接口
播放
循环
停止
恢复和播放声音最简单的方法是通过Applet类的play()方法。调用play()方法有如下二种方式:
play()-带有一个参数，一个 URL对象,装载并演奏储存在 URL处的声音片断。
play()-带有二个参数，基本 URL和文件夹路径名,装载并演奏声音文件。第一参数经常是对getCodeBase()或 getDocumentBase()的调用。
下列代码片断举例说明了直接播放 hello.au的方法。AU文件与小应用程序位于相同文件夹或目录。
play(getCodeBase(), "hello.au");
play()一旦被调用立刻开始恢复和播放声音。如果声音文件不能被查找,将不会有出错信息,仅仅是沉默。
启动和停止声音文件,或循环播放,你必须用 applet的 getAudioClip方法把它装载进入 AudioClip对象，类似上面play()方法的参数，getAudioClip方法要用一个或两个参数,当作播放的指示。 第一个或唯一的一个参数是 URL参数，用来指示声音文件的位置，第二参数是文件夹路径指针。
下列代码行举例说明加载声音文件进入剪贴对象:
AudioClip co = getAudioClip(getCodeBase(), "horns.wav");
getAudioClip()方法仅仅能被applet内调用。随着JAVA2的引入，应用程序也能用Applet类的newAudioClip方法装入声音文件。前一例子可以改写如下以用于Java应用程序:
AudioClip co = newAudioClip("horns.wav");
在你已创建 AudioClip对象之后,你能用该对象调用play()、loop()以及stop()方法。如果 getAudioClip或 newAudioClip方法不能找到指定的声音文件, AudioClip对象的值将是空的。试着播放空对象会导致出错，所以标准的过程首先是对该条件进行检测。
接下来是一个完整的程序设计示例，该程序将产生一个applet，当鼠标在该小应用程序applet范围内按下时会播放 flute+hrn+mrmba.au音乐样本。此AU示例文件与applet在相同目录或文件夹下的。
import java.applet.*;
import java.awt.event.*;
public class PlayAudio extends Applet
implements MouseListener {
AudioClip audio;
public void init() {
audio = getAudioClip(getDocumentBase(),
"flute+hrn+mrmba.au");
addMouseListener(this);
}
public void mousePressed(MouseEvent evt) {
if (audio != null) audio.play();
}
public void mouseEntered (MouseEvent me) {
}
public void mouseExited (MouseEvent me) {
}
public void mouseClicked (MouseEvent me) {
}
public void mouseReleased(MouseEvent me) {
}
}
注意： 在许多JAVA2技术书籍中，mouseDown()方法确实是JAVA 1.0事件模型的一部分。使用该方法会有一定的危险，因为该方法在将来可能不会被支持。在JAVA2平台下将MouseListener与mousePressed结合使用是优先的选择。
API 1.0-质的飞跃
注意：下列备注是以JAVA API的早期版本0.86为基础的。虽然目前这里讨论的大多数对象和概念与过去保持一致，但由于该API版本已经终止，出现某些改变的可能是存在的。
JAVA声音 1.0 API为JAVA平台定义了一整套的基本的底层音频处理功能。它提供如下接口为:
音频捕获和播放
IDI合成及序列化
这两个主要的功能模块在各自的程序包中提供。
javax.media.sound.sampled-该程序包明确地说明了捕获、混合以及回播数字采样音频的界面。
javax.media.sound.MIDI-该程序包提供MIDI合成、序列化以及事件传送的界面。
JAVA 1.0 API具备如下特性:
数字音频
频捕获－从输入源例如麦克风进行数据捕获。
音和重播－将各种输入源的声音混合并重播。
制与编码－调整增益、定位、回音处理等等，以及进行格式转换。
态及其提示－当重播开始和结束、设备打开或关闭以及其他相关事件发生时接收事件。
对MIDI的支持
MIDI消息－交换消息（打开音符，关闭音符，诸如此类）
合成－从MIDI数据装入乐器并产生声音。
序列化－装入一个MIDI序列，开始和停止播放，以及调整节奏。<／li>
工具
件输入输出－读写通用音频文件例如WAV，AIFF及MIDI
置－查询系统来获得组件和设备的信息；安装或取消编码、文件分析器和设备等。
数字化音频
通道
Kara Kytle, JAVA声音 API主管工程师和系统设计师说:"Channel是音频管道中的基本功能部件"。实现Channel界面的类代表着该"管道"的一个元素，例如硬件设备，一个声音合成器，或者是一个单音频流。
InputChannel和 OutputChannel继承了Channel,分别用于读入被捕获的数据和为播放写数据。子界面Clip支持对预装入的音频数据循环播放和重新定位。Device表示任何用于捕获、播放或混和音频的硬件或软件设备。
该界面的层次结构如下图所示。参考包javax.media.sound.sampled。
当一个Channel打开时,它为自己保留了系统资源 ,并且当它结束时,这些资源被释放给其他的应用程序和对象使用。用isOpen()方法可以查询Channel是打开还是关闭的。数据的处理通常由子界面方法比如read()方法来启动，这部分在InputChannel界面说明描述 (请看JAVA声音 API的说明书)。
处理方法使Channel处于负责输入或输出音频数据的状态。用isActive方法可以识别Channel是否处于这种状态。通过调用pause()方法可以使通道处于暂停状态，此状态可以通过isPaused()方法判别。当通道被暂停时,有三种选择：保留数据(缺省),用flush()方法丢弃内部缓冲器中的数据，或用drain()方法使内部缓存中的数据被立即处理。
对象事先可以注册，这样每当通道状态改变时它都可以收到通告信息。该注册对象必须实现Channel.Listener界面，该界面仅包含一个方法update()。当Channel打开、结束、启动、及停止时，该方法都将被调用。当Channel开始或停止活动以及开始或停止捕获数据时，会产生start或stop事件。
输入通道
InputChannel是被捕获的音频数据的源头。该界面提供了方法，可从 InputChannel缓冲器读取被捕获的数据，并判断当前可读的数据量。如果应用程序试图读过多的数据,该读方法阻塞，直到所需读取数据达到为止。
输出通道
OutputChannel接收用于播放的音频数据。这接口提供方法，将要播放的数据写入OutputChannel的缓冲区，并能判断该通道不间断可接收的数据量。如果应用程序试图写过量的数据，该读方法阻塞，直到有足够数据为止。
剪贴
Clip接口表示一个特殊的通道，它可以在播放之前先装入音频数据。由于数据是预装入的，而不是流入的，所以clip可以支持持续查询、循环播放、以及重新定位播放。
设备
Device界面为表示音频设备的类提供方法。音频设备可以是共享的也可是独占的系统资源，它可以是基于硬件的，也可基于软件的，还可是同时基于两者的。它能被重复地打开和关闭，它能时常说明它的内在特性及支持的音频格式。同时，它也提供信息对象来描述设备。
JAVA声音 API进一步描述三种设备子界面:
InputDevice
InputDevice界面提供一个方法getInputChannel来获得一个InputChannel对象，从中捕获可读的音频数据。
OutputDevice
OutputDevice界面提供一个方法getOutputChannel来获得一个OutputChannel对象，音频数据可以写入该输出通道，并予播放。
Mixer
Mixer支持多个InputChannel和/或Clip。 另外,它提供了查询方法，从中可得到它所支持的通道数量，它也提供了支持同步暂停和唤醒多个通道播放的方法。
控件
通道和音频端口 (比如扬声器和麦克风)一般能支持一组控件比如增益和定位。通过将它的类作为参数传给getControl()方法，JAVA声音 API的通道对象和端口对象可以获得一个特别的控件。
编码器
Codecs可以对音频数据编码和解码，允许在不同格式和编码之间转换。JAVA声音 API通过AudioSystem类中的方法为这些转换提供了高级接口。如果给了一个特殊的音频流，应用程序会查询音频系统来找到相应的转换，从而得到指定格式的音频流。
文件和流
音频流是与音频数据格式和数据长度相关的输入流，文件流是与文件类型和数据长度相关的输入流。JAVA声音 API在AudioSystem类中为音频文件和音频流之间的转换提供了接口。
查询和访问安装组件
AudioSystem类充当到采样音频系统资源入口的角色。该类允许程序员查询和访问输入设备、输出设备以及安装好的混音设备。另外，AudioSystem包含许多在不同音频数据格式间转换的方法。它也提供一些方法，使得在不需要对设备直接操作的情况下，直接获得输入通道或输出通道。
系统配置-服务提供者界面(SPI)
对采样音频系统的配置是由javax.media.sound.sampled.spi包来完成的。通过 AudioConfig类的方法，可以在系统中安装或卸载设备，并且可以建立起缺省状态。服务提供者可以希望提供和安装他们自己的编码器和分析器。这个包提供了完成这种功能的机制。
MIDI
javax.media.sound.MIDI程序包描述了 MIDI事件传送、合成、以及序列化的界面。下面介绍该程序包中所用到的主要概念。
传送
基本的MIDI传送界面是 MidiDevice。所有设备为列出其所支持的模式和查询当前模式提供了方法。设备支持监听器，可以监听各种事件如打开和关闭事件，并且有一个信息对象来描述设备状态。
通常,设备是MIDI事件的传送器或接收器之一。传送器界面提供了一些方法来设置和查询接收器，该接收器接收由该传送器发送出的MIDI事件。接收器为接收MIDI事件提供方法。
基本的 MidiEvent对象是通过一个消息说明事件类型、数据长度、以及状态。它也为涉及MIDI计时的设备例如音序器提供准确的计时信号。
合成器
合成器界面是一种生成声音的特殊类型的接收器。它也提供一些方法来管理声音库和乐器。另外,合成器可以支持一组全局的非-MIDI控件例如增益和定位。它也提供对一组MIDI通道的访问，实际上，声音就是通过这些通道产生的。
MidiChannel界面提供一组方法来表达公用的MIDI声音消息例如 noteON, noteOff以及controlChange。还支持对当前通道状态的查询。
序列化
Sequencer界面继承了MidiDevice,它提供了完成基本MIDI序列化操作的方法。音序器可以装载和播放一个序列，查询和设置节奏，并且控制主从同步方式。一个应用程序还可以通过注册使得音序器在处理设备单元和控制器事件时通知自己。
文件和序列化
序列化对象代表一个来自一个或多个磁道的MIDI序列以及相关的计时信息。一个磁道对象包含一系列加上时间标记的MIDI事件。
JAVA声音 API在 MidiSystem类中为在MIDI文件和序列化对象之间转换提供了高级的接口。
查询和访问已经安装了的组件
MidiSystem类充当MIDI音乐系统入口的角色。它提供相关设备的信息并对之进行访问，这些设备包括传送器,接收器,合成器,以及音序器。它也提供了对SoundBank对象的访问。
系统配置-服务提供者接口(SPI)
MIDI系统的配置由javax.media.sound.midi.spi包来完成的。通过MidiConfig类的方法，设备可以安装到系统中或从中卸载，并且可以建立起缺省状态。服务提供者可以希望提供和安装他们自己的文件和声音库分析器。该SPI程序包中包括了完成这种功能的机制。
现在让我们看看能用这些类和方法做什么。请仔细检查一下。
ToySynth应用程序
ToySynth应用程序试验了早期对JAVA声音 API存取的方式，主要是通过提供一系列设备设置，包括MIDI通道选择、音量控制、立体声定位、回声处理、以及其他选项。通过敲击键盘就可以演奏使用指定设备的乐曲，而这些设备又都是通过JAVA声音引擎来实现的。
完整的ToySynth.java代码样本。
下载JAVA声音 API的同时可以得到示范应用程序及其源代码。
JAVA声音 API的市场目标
JAVA声音 API为各种各样的应用程序提供了声音支持。下面列举一些可能的应用。
通信框架
通过计算机召开远程会议
在计算机上实现电话功能
内容发布系统
音乐
信息流
媒体传播
交互式应用程序
游戏
WEB站点
产生动态内容
工具集
内容产生
各种工具
在此基础上我们能做什么？
JAVA 2通过 AudioClip界面来访问JAVA声音音频引擎。随着1.0 API的发布,我们所曾经探索的应用领域，就将提供给各地的开发人员使用。
"现在,我们通过在JAVA2平台中加入真实声音的支持，启动了计算机桌面多媒体市场。以后,我们将看见我们的JAVA声音API技术广泛应用于专业人员、普通用户以及国际互连网上的音频应用", Michael Bundschuh说。
电影和录音带公司通过使用JAVA声音 API技术可以获得专业质量音频效果。在JAVA声音引擎中实现支持24位音频和多通道配置将鼓励专业人员开发出高级的声音编辑和播放应用程序。
根据 Kara Kytle所说，对更多的音频数据类型例如MP3的支持已经被提到议事日程。"另一个议程是从外部设备对MIDI数据进行捕获。这将很快实现。"她说。
"JAVA声音 API技术已经可以很好地适用于通过WEB的音频播放。"Bundschuh说。"但是我们总是跟踪最新的技术，并且开发象MP3这样的技术，同时还要保护音乐文件的安全传送。我们计划在JAVA声音 API今后的版本中提供对上述技术的支持"。
随着最近市场的发展，象播放基于WEB音乐上的竞争策略一样，大家都已经把发展数字化声音放在中心的位置。新的媒体技术不断涌现，声音将扮演核心的角色。JAVA声音 1.0 API将适时地加入到新的关键应用程序开发行列中来。
现可以得到ToySynth.java程序代码
该程序通过图形形象地表示出一个合成器的样子，通过鼠标去按合成器上的键来演奏乐曲。你可以通过声音设置以及其他选项去改变声音的基调。好好玩吧。
5 07, 2007
首先要说明的是，在组件上方便的显示图象是 swing 比 AWT 优越的特性之一，暂时我还没看到如何在 AWT 中实现这一方法，如果你知道，请来信告诉我。
在 swing 中,button, lable 等组件都可轻易的用图象来改变它的外观，以 button 为例，当创建一
个 button 对象的时候通常是这样的：
JButton button = new JButton("Click me");
这样就创建了一个 button 对象，上面显示的文字是 Click me.
现在我们来稍做改动：
ImageIcon buttonIcon = new ImageIcon("button.gif", "a background of button");
JButton button = new JButton(buttonIcon);
这两行代码就达到了目的，在 button 上显示了图象 button.gif,注意我们用的是 ImageIcon 类，而
不是 Image 类。ImageIcon 中的第二个参数是对 ImageIcon 对象的描述，这个参数以后可能会被
assistive 技术用到。
如果想在 button 上同时显示文字和图象，还可以这样：
JButton button = new JButton("Click me", buttonIcon);
另外，还可以定义图象在 组件上的位置，如：
JButton button = new JButton("Click me", buttonIcon, JButton.CENTER);
最后，在顺便的讲一下如何改变你的 applet/application 上角的那个小图标，怎么样，看那杯咖啡厌烦了把？
让我们来换上自己的图标吧,我用的是setIconImage方法。
在 applet中，定义了一个image对象后就可以直接以它为参数来使用 setIconImage() 方法了，
而在 application 中，还需要由 ImageIcon 类转换到 Image 对象去。可能是我笨，不知道如何在application中
有什么简单的办法可以直接使用 Image 类，谁知道请写信给我，十分感谢。
URL imgURL = getClass().getResource("title.gif");
ImageIcon icon = new ImageIcon(imgURL);
setIconImage(icon.getImage());
5 07, 2007
数字音频格式有很多种，其质量与采样频率和采样精度两个参数有关。频率的表示单位为赫兹〔Hz〕，它表示每秒采样次数。采样频率越高，音质就越好。采样精度为每次采样所存储的数据数量，它决定每个数字信号所能够表示的离散振幅的数量。存储每个样本的数据越多，音质就越好。但是高品质的声音需要占用大量的内存和磁盘空间。考虑到网络带宽，在Internet连接上传输就需要花费很长的时间。对于Applet来说，保证声音文件的最小化是极为重要的。Java能够支持以下四种声音格式：
◆AU
◆AIFF
◆WAVE
◆MIDI
第一种声音格式AU为以前的Java 1.1版本支持的唯一的声音格式。采样频率为8000赫兹，采样精度为8位。AIFF和WAVE与AU格式一样，都用来表示数字化的声音。其中，WAVE格式提供了更宽范围的音质。MIDI格式专用于音乐，并且以音符与乐器而不是数字化的声音来描述声音的。
关于声音的创建：声音关键工具为Windows9X中的标准应用程序?录音机。录制的格式为WAVE。另外还有很多专业水准的应用程序，采样和编辑数字化的声音，及格式的转换。
资源需求：
■ 硬件资源需求：
⑴声卡
⑵音箱
＃如需要录制声音，这还需麦克风。
■ 软件资源需求：
⑴windows9X操作系统
⑵网络浏览器
⑶Java插件/运行时间环境
处理方案一
JAVA2开始，爪哇语言能够支持上述四种声音格式。简单的方法为在java中通过Applet类的AudioClip()接口来装载声音。该接口风钻了有关声音片断的常用方法，具有对播放声音片断的最小支持。
该接口定义了如下方法：
■ play()
语法：void play()
功能：开始播放声音片断。
不论声音片断是否已经在播放，都从头播放。播放一遍但不重复。
■ loop()
语法：void loop()
功能：循环播放声音片断。
调用该方法是不论声音片断是否已在播放，都从头开始播放。
■ stop()
语法：void stop()
功能：停止播放声音片断。
AudioClip接口可以通过getAudioClip()及getCodeBase()方法来获取声音片断及
URL地址。可以利用此方法在WEB页中播放指定的声音片断。
＃需求：基于JDK1.2以上版本的开发环境。如果只播放AU格式的声音文件，JDK1
.1就可。
附：soundtest.html源代码
《HTML》
《HEAD》
《TITLE》
HTML Test Page
《/TITLE》
《/HEAD》
《BODY》
《APPLET
CODEBASE = "" CODE = "test.class" NAME = "TestApplet" WID
TH = 400 HEIGHT = 200 HSPACE = 0 VSPACE = 0 ALIGN = mi
ddle》
《PARAM NAME = "clip" VALUE = "sound.AU"》
《/APPLET》
《/BODY》
《/HTML》
附：test,java源代码
package SoundTest;
import java.awt.*;
import java.awt.event.*;
import java.applet.*;
import javax.swing.*;
import java.net.*;
public class test extends JApplet {
boolean isStandalone = false;
String sound;
JButton jButtonPlay = new JButton();
JButton jButtonLoop = new JButton();
JButton jButtonStop = new JButton();
JLabel jLabel1 = new JLabel();
AudioClip clip;
//Get a parameter value
public String getParameter(String key, String def) {
return isStandalone ? System.getProperty(key, def) :
(getParameter(key) != null ? getParameter(key) : def);
}
//Construct the applet
public test() {
}
//Initialize the applet
public void init() {
try {
jbInit();
}
catch(Exception e) {
e.printStackTrace();
}
}
//Component initialization
private void jbInit() throws Exception {
jButtonPlay.setText("Play");
jButtonPlay.setBounds(new Rectangle(50, 85, 80, 40));
jButtonPlay.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(MouseEvent e) {
jButtonPlay_mouseClicked(e);
}
});
this.setSize(new Dimension(400,200));
this.getContentPane().setLayout(null);
jButtonLoop.setText("Loop");
jButtonLoop.setBounds(new Rectangle(150, 85, 80, 40));
jButtonLoop.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(MouseEvent e) {
jButtonLoop_mouseClicked(e);
}
});
jButtonStop.setText("Stop");
jButtonStop.setBounds(new Rectangle(250, 85, 80, 40));
jButtonStop.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(MouseEvent e) {
jButtonStop_mouseClicked(e);
}
});
jLabel1.setText("Sound Test Demo");
jLabel1.setBounds(new Rectangle(109, 28, 186, 28));
this.getContentPane().add(jButtonPlay, null);
this.getContentPane().add(jButtonStop, null);
this.getContentPane().add(jButtonLoop, null);
this.getContentPane().add(jLabel1, null);
try { sound = this.getParameter("clip", "sound.AU"); } catch (Exce
ption e) { e.printStackTrace(); }
if(sound!=null){
try{
clip=JApplet.newAudioClip (new URL(getCodeBase(),sound));
}
catch(MalformedURLException e){
System.out.println ("Bad URL");
}
}
}
//Get Applet information
public String getAppletInfo() {
return "Applet Information";
}
//Get parameter info
public String[][] getParameterInfo() {
String[][] pinfo =
{
{"clip", "String", "sound.AU"},
};
return pinfo;
}
void jButtonPlay_mouseClicked(MouseEvent e) {
clip.play();
}
void jButtonLoop_mouseClicked(MouseEvent e) {
clip.loop();
}
void jButtonStop_mouseClicked(MouseEvent e) {
clip.stop();
}
}
处理方案二
利用JAVA媒体框架中的Sound API来处理声音片断。Sound API 被包含在SUN公司的JAVA媒体框架中，也包含在JDK1.3版本中。编译源代码需要支持JDK1.3的开发环境和运行时间环境。
可以利用Sound API在网页中加入Applet的方式达到要求。但浏览器需要通过Java插件或运行时间环境的支持。
Sound API主要包括以下四部分：
Packages
javax.sound.midi 提供MIDI (Musical Instrument Digital Interface)的I/O、
序列、合成的接口和类。
javax.sound.midi.spi Supplies interfaces for service providers to impl
ement when offering new MIDI devices, MIDI file readers and writers, o
r sound bank readers.
javax.sound.sampled 为采样数字音频的捕获、处理、重放提供接口和类。
javax.sound.sampled.spi Supplies abstract classes for service provider
s to subclass when offering new audio devices, sound file readers and
writers, or audio format converters.
处理方案三
利用JAVA 3D中的sound类。该类似声音资源的抽象定义。每一个具体的声音对象都可以应用sound的方法。
Sound类的类关系如下：
java.lang.Object
+-javax.media.j3d.SceneGraphObject
+-javax.media.j3d.Node
+-javax.media.j3d.Leaf
+-javax.media.j3d.Sound
sound类的子类有：
⒈BackgroundSound
⒉PointSound
⒊ConeSound
使用上述三种声音的步骤如下：
⒈定义并生成一个MediaContainer对象，同时提供对象所需要的声音文件，通常
要单独设置一个存放AU/WAV声音文件的目录。
⒉定义一个BackgroundSound/ PointSound/ ConeSound对象，根据需要，设置声
音的是否循环、强度大小等参数，设置它的作用范围并setEnable用使其开始作用。
⒊根据具体的对象设置坐标系。
＃JAVA 3D应用程序只能播放au/wav格式的声音文件。不能播放midi文件
5 07, 2007
<script language="JavaScript1.2"><!-- Begin
var no = 5; // snow number
var speed = 1; // smaller number moves the snow faster
var snowflake = "fl.gif";
var ns4up = (document.layers) ? 1 : 0; // browser sniffer
var ie4up = (document.all) ? 1 : 0;
var dx, xp, yp; // coordinate and position variables
var am, stx, sty; // amplitude and step variables
var i, doc_width = 800, doc_height = 600;
if (ns4up) {
doc_width = self.innerWidth;
doc_height = self.innerHeight;
} else if (ie4up) {
doc_width = document.body.clientWidth;
doc_height = document.body.clientHeight;
}
dx = new Array();
xp = new Array();
yp = new Array();
am = new Array();
stx = new Array();
sty = new Array();
for (i = 0; i < no; ++ i) {
dx[i] = 0; // set coordinate variables
xp[i] = Math.random()*(doc_width-50); // set position variables
yp[i] = Math.random()*doc_height;
am[i] = Math.random()*20; // set amplitude variables
stx[i] = 0.02 + Math.random()/10; // set step variables
sty[i] = 0.7 + Math.random(); // set step variables
if (ns4up) { // set layers
if (i == 0) {
document.write("<layer name="dot"+ i +"" left="15" ");
document.write("top="15" visibility="show"><img src="");
document.write(snowflake + "" border="0"></layer>");
} else {
document.write("<layer name="dot"+ i +"" left="15" ");
document.write("top="15" visibility="show"><img src="");
document.write(snowflake + "" border="0"></layer>");
}
} else if (ie4up) {
if (i == 0) {
document.write("<div id="dot"+ i +"" style="POSITION: ");
document.write("absolute; Z-INDEX: "+ i +"; VISIBILITY: ");
document.write("visible; TOP: 15px; LEFT: 15px;"><img src="");
document.write(snowflake + "" border="0"></div>");
} else {
document.write("<div id="dot"+ i +"" style="POSITION: ");
document.write("absolute; Z-INDEX: "+ i +"; VISIBILITY: ");
document.write("visible; TOP: 15px; LEFT: 15px;"><img src="");
document.write(snowflake + "" border="0"></div>");
}
}
}
function snowNS() { // Netscape main animation function
for (i = 0; i < no; ++ i) { // iterate for every dot
yp[i] += sty[i];
if (yp[i] > doc_height-50) {
xp[i] = Math.random()*(doc_width-am[i]-30);
yp[i] = 0;
stx[i] = 0.02 + Math.random()/10;
sty[i] = 0.7 + Math.random();
doc_width = self.innerWidth;
doc_height = self.innerHeight;
}
dx[i] += stx[i];
document.layers["dot"+i].top = yp[i];
document.layers["dot"+i].left = xp[i] + am[i]*Math.sin(dx[i]);
}
setTimeout("snowNS()", speed);
}
function snowIE() { // IE main animation function
for (i = 0; i < no; ++ i) { // iterate for every dot
yp[i] += sty[i];
if (yp[i] > doc_height-50) {
xp[i] = Math.random()*(doc_width-am[i]-30);
yp[i] = 0;
stx[i] = 0.02 + Math.random()/10;
sty[i] = 0.7 + Math.random();
doc_width = document.body.clientWidth;
doc_height = document.body.clientHeight;
}
dx[i] += stx[i];
document.all["dot"+i].style.pixelTop = yp[i];
document.all["dot"+i].style.pixelLeft = xp[i] + am[i]*Math.sin(dx[i]);
}
setTimeout("snowIE()", speed);
}
if (ns4up) {
snowNS();
} else if (ie4up) {
snowIE();
}
// End -->
</script>
5 07, 2007
Image I/O 包及对 JDK 的要求如果你的 servlet 要动态生成图象，首先你需要 image I/O，明确的说，你需要生成一图片来响应HTTP请求。核心 Java API 没有直接提供用于保持任何图象的功能。然而，你可以用 Sun 的 Java 1.1 类库来做 image I/O。而且 Sun 的 1.2 版的 image I/O 提供了对 JPEG 图象进行编码和解码的包。因为这些代码在 com.sun 包中，不是核心API的一部分，也不是标准的扩展包，因此，会影响代码的可移植性。
使用 jdk 1.2 将比 jdk 1.1 版容易的多，本文介绍 jdk 1.2 下的实现方法。示例有三个步骤：创建、绘制、保存。在本例仅仅示范如何画一个椭圆，当然你可以根据你的需要修改。例子使用了 com.sun.image.codec.jpeg 包生成 JPEG 文件。如果要生成 GIF 文件，你可以使用第三方的包，如 Acme Labs 的 GIF Encoder。
1. 使用适当的尺寸创建一个 BufferedImage 对象：
BufferedImage
image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
2. 在 image 对象上绘制你想要的图象。假设你想要一个白色的背景，你需要画一个白色填充的矩形。否则背景将是缺省的黑色：
Graphics g = image.getGraphics();
g.setColor(Color.white);
g.fillRect(0,0, width, height);
g.setColor(Color.red);
g.drawOval(0, 0, width, height);
3. 使用 com.sun.image.codec.jpeg 包输出 BufferedImage：
response.setContentType(”image/jpeg”);
ServletOutputStream out = response.getOutputStream();
JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);
encoder.encode(image);
out.close();
5 07, 2007
您不必从文件中读取所有的图像 ? 您可以创建自己的图像。要创建自己的图像，最灵活的方法是用一个 BufferedImage 对象，它是 Image 类的一个子类，它把图像数据存储在一个可以被访问的缓冲区中。它还支持各种存储像素数据的方法：使用或不使用 alpha 通道、不同种类的颜色模型以及颜色组件的各种精确度。ColorModel 类提供一种灵活的方法定义各种颜色模型，以和 BufferedImage 对象一起使用。为了理解颜色模型工作的基本知识，我们将只使用一个缺省的颜色模型，其颜色组件由 RGB 值和一个缓冲类型（存储 8 位的 RGB 颜色值加上一个 alpha 通道）组成。这一缓冲类型由 BufferedImage 类中的常量 TYPE_INT_ARGB 指定，它意味着每个像素要用一个 int 值。每个像素的值是以 8 位字节形式存储一个 alpha 组件加上 RGB 颜色组件。我们可以用给定的宽度和高度创建一个这种类型的 BufferedImage 对象，代码语句如下：int width = 200;
int height = 300;
BufferedImage image = new BufferedImage(width,
height,BufferedImage.TYPE_INT_ARGB);
这段代码创建了一个 BufferedImage 对象，它代表一个 200 像素宽、300 像素高的图像。为了应用这个图像，我们需要有图形上下文，而 BufferedImage 对象的 createGraphics() 方法就返回一个与该图像相关的 Graphics2D 对象：
int width = 200;
Graphics2D g2D = image.createGraphics();
使用 g2D 对象的操作会修改 BufferedImage 对象 image 的像素。利用这个对象，您现在完全有能力应用 BufferedImage 对象。您可以绘制形状、图像、GeneralPath 对象或任何别的东西，还可以为图形上下文设置 alpha 组合对象。您同时还拥有 Graphics2D 对象提供的全部仿射变形能力。
如果要从 BufferedImage 对象获取单个像素，可以通过调用它的 getRGB() 方法，并提供该像素的 x,y 坐标作为 int 类型的参数。这个像素会按 TYPE_INT_ARGB 格式以 int 类型返回，它由四个 8 位的值（代表 alpha 值和 RGB 颜色组件）组成一个 32 位字。同时 getRGB() 还有一个重载的版本，它从一部分图像数据中返回一个像素数组。您也可以通过调用 setRGB() 方法来设置单个像素。前两个参数是该像素的坐标值，第三个参数是待设定的值，类型为 int。这个方法也有一个版本可以设置像素数组的值。
至此我们已经完成了像素操作的学习。下面我们要建立一个 applet，它在 Wrox 徽标背景上使 BufferedImage 对象具有动画效果。我们的示例还将演示怎样能让图像局部透明。applet 的基本内容如下所示：
import java.awt.*;
import java.awt.image.*;
import java.awt.geom.*;
import javax.swing.*;
public class ImageDrawDemo extends JApplet
{
// The init() method to initialize everything...
// The start() method to start the animation...
// The stop() method to stop the animation...
// The ImagePanel class defining the panel displaying the animation...
// Data members for the applet...
}
创建一个图像
一个子图形是一个小的图形图像，可以将其绘制在静态图像以创建动画。要创建动画效果，您只要随着时间推移，在不同的位置和方向上绘制子图形。当然，利用坐标系的变形可以使之简化许多。游戏经常使用子图形 ? 由于您只需要在一个静态背景上绘制子图形，所以可以使动画所占用的处理器的时间大大减少。我们对使用 BufferedImage 对象的兴趣意味着我们将不再花费精力去研究减少处理器时间的最佳技术，而是把注意力放在理解怎样才能在一个程序内部创建和使用图像上。
我们的 BufferedImage 对象看上去如图 1 中的图像：
图 1. BufferedImage 子图形
这个图像是一个以 spriteSize 为边长的正方形。图像其它部分的尺寸值都与这个边长相关。实际上这里只有两个几何实体，一条线和一个圆，都在不同位置和方向重复出现。如果我们创建一个 Line2D.Double 对象代表线，创建一个 Ellipse2D.Double 对象代表圆，那么我们就可以通过移动用户坐标系和画这两个对象中的一个或其它的对象而画出整个图像。
如果是按真正面向对象的方法，应该定义一个类代表一个子图形，可能是作为 BufferedImage 的一个子类，但由于我们是在探索使用 BufferedImage 对象的技巧，因此用一个 createSprite() 方法来画出 BufferedImage 对象上的子图形会更适合我们的目的。因为该方法只是我们的 applet 类的一个成员，所以我们将为 applet 添加数据成员以存储任何需要的数据。您可以把我们将使用的数据成员插入到 applet 类中，如下所示：
double totalAngle; // Current angular position of sprite
double spriteAngle; // Rotation angle of sprite about its center
ImagePanel imagePanel; // Panel to display animation
BufferedImage sprite; // Stores reference to the sprite
int spriteSize = 100; // Diameter of the sprite
Ellipse2D.Double circle; // A circle - part of the sprite
Line2D.Double line; // A line - part of the sprite
// Colors used in sprite
Color[] colors = {Color.red , Color.yellow, Color.green , Color.blue,
Color.cyan, Color.pink , Color.magenta, Color.orange};
java.util.Timer timer; // Timer for the animation
long interval = 50; // Time interval msec between repaints
这些成员的一般用途可以从注释中清楚地看到。下面我们要看一看开发代码时它们是怎样被使用的。
createSprite() 方法需要做的第一件事就是创建 BufferedImage 对象 sprite，然后我们还需要一个 Graphics2D 对象用于在 sprite 图像上绘画。下面就是完成这些操作的代码：
BufferedImage createSprite(int spriteSize)
{
// Create image with RGB and alpha channel
BufferedImage sprite = new BufferedImage(spriteSize, spriteSize,
BufferedImage.TYPE_INT_ARGB);
Graphics2D g2D = sprite.createGraphics(); // Context for buffered image
// plus the rest of the method...
}
sprite 对象的宽和高的值都是 spriteSize，图像的类型为 TYPE_INT_ARGB，就是说每个像素的 alpha 值和颜色组件是以一个单独的 int 值存储的，而颜色是以 8 位的红、绿、蓝组件的形式存储的。这意味着我们的 sprite 图像将占用 40,000 字节，这只是浏览一个网页会占用的内存的很小一部分。而这并不影响网页的下载时间，因为在执行 applet 的时候，这部分内存是在本地机器上被分配的。除了作为网页本身的 HTML 文件的内容外，下载时间还取决于 applet 的 .class 文件的大小，以及在它执行时下载的图像或其它文件。
创建一个透明的背景
在 sprite 图像中，alpha 通道是很重要的，因为我们希望背景能完全透明。在绘画过程中，只有 sprite 对象本身应该是可见的，而不是整个 100×100 的矩形图像。我们可以很容易地实现这一目的，只要开始先使整个 sprite 图像区域透明（即，alpha 值为 0.0f），然后把我们想要画的图形绘制在上面，使之不透明（alpha 值为 1.0f）。以下是使整个图像透明的代码：
// Clear image with transparent alpha by drawing a rectangle
g2D.setComposite(AlphaComposite.getInstance(AlphaComposite.CLEAR, 0.0f));
Rectangle2D.Double rect = new Rectangle2D.Double(0,0,spriteSize,spriteSize);
g2D.fill(rect);
我们首先使用 AlphaComposite 对象按照 CLEAR 规则设置 alpha 合成值，把颜色组件设置为零，又通过设置 alpha 值为 0.0f，使之透明。然后我们填充一个覆盖整个图像区域的矩形。我们不必设置颜色值，因为根据 CLEAR 规则，每个像素的前景和背景色所占成分都是零，所以这两者都不参与像素的生成。但我们仍要填充该矩形，因为这将确定被操作的图像像素。
这里，我们可以稍微了解一下怎样控制图像的质量。
着色微调
对着色操作的许多方面而言，都有一个在质量和速度间选择的问题。着色操作就像大多数事情一样 ? 质量是需要代价的，而这里的代价就是处理时间。所有的着色操作都有缺省设置，其中存在一个选择，缺省设置是特定于平台的，但您可以通过调用用于着色的 Graphics2D 对象的 setRenderingHint() 方法自己选择。虽然只有一些微调，如果您的计算机不支持与您指定的微调相对应的着色操作选项，这些微调就无法生效。
通过添加以下对 createSprite() 方法的调用，可以确保得到由我们的 alpha 合成操作可能生成的最好效果。
BufferedImage createSprite(int spriteSize)
{
// Create image with RGB and alpha channel
BufferedImage sprite = new BufferedImage(spriteSize, spriteSize,
BufferedImage.TYPE_INT_ARGB);
Graphics2D g2D = sprite.createGraphics(); // Context for buffered image
// Set best alpha interpolation quality
g2D.setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION,
RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);
// Clear image with transparent alpha by drawing a rectangle
g2D.setComposite(AlphaComposite.getInstance(AlphaComposite.CLEAR, 0.0f));
Rectangle2D.Double rect = new Rectangle2D.Double(0,0,spriteSize,spriteSize);
g2D.fill(rect);
// plus the rest of the method...
}
RenderingHints 类定义了多种着色微调，它们存储在一个映射集的 Graphics2D 对象里。setRenderingHint() 方法的参数是一个键以及对应的键值。在我们的代码中，第一个参数是代表 alpha 合成微调的键，第二个参数是该微调的值。该微调的其它可能的值有 VALUE_ALPHA_INTERPOLATION_DEFAULT，代表平台缺省值；以及 VALUE_ALPHA_INTERPOLATION_SPEED，代表追求速度而不是质量。
您还可以为下面的键提供微调：
键 描述
KEY_ANTIALIASING 决定是否使用抗锯齿。当着色有倾斜角度的线时，通常会得到一组阶梯式的像素排列，使这条线看上去不平滑，经常被称为 锯齿状图形。抗锯齿是一种技术，它设置有倾斜角度的线的像素亮度，以使线看起来更平滑。因此，这个微调是用来决定在着色有倾斜角度的线时是否在减少锯齿状图形上花费时间。可能的值有 VALUE_ANTIALIAS_ON, _OFF 或 _DEFAULT。
KEY_COLOR_RENDERING 控制颜色着色的方式。可能的值有 VALUE_COLOR_RENDER_SPEED, _QUALITY 或 _DEFAULT。
KEY_DITHERING 控制如何处理抖动。抖动是用一组有限的颜色合成出一个更大范围的颜色的过程，方法是给相邻像素着色以产生不在该组颜色中的新的颜色幻觉。可能的值有 VALUE_DITHER_ENABLE, _DISABLE 或 _DEFAULT。
KEY_FRACTIONALMETRICS 控制显示文本的质量。可能的值有 VALUE_FRACTIONALMETRICS_ON, _OFF 或 _DEFAULT。
KEY_INTERPOLATION 确定怎样做内插。
在对一个源图像做变形时，变形后的像素很少能够恰好对应目标像素位置。在这种情况下，每个变形后的像素的颜色值不得不由周围的像素决定。
内插就是实现上述过程。有许多可用的技术。可能的值，按处理时间从最多到最少，是 VALUE_INTERPOLATION_BICUBIC, _BILINEAR 或 _NEAREST_NEIGHBOR。
KEY_RENDERING 确定着色技术，在速度和质量之间进行权衡。可能的值有 VALUE_RENDERING_SPEED, _QUALITY 或 _DEFAULT。
KEY_TEXT_ANTIALIASING 确定对文本着色时是否抗锯齿。可能的值有 VALUE_TEXT_ANTIALIASING_ON, _OFF 或 _DEFAULT。
我们绕得已经够远了。让我们回到绘制 sprite 上……
5 07, 2007
在 application 中显示图象有些人用的方法比较麻烦，要用到 Toolkit 类。这里我发现了一个教为简单的办法，就是用getImage()方法来从一个 ImageIcon 对象获取 Image 对象。
具体做法如下：
//获取图象文件路径
//getResource()方法会自动的去CLASSPATH中找你的图象文件，这不失为一中好的办法
//即使你的图象文件在jar包中，我们也可以很轻易的找到它
URL imgURL = getClass().getResource("img/test.gif");
//建立ImageIcon 类
ImageIcon icon = new ImageIcon(imgURL);
//由icon得到img
Image img = icon.getImage();
这样一来，把我上一篇文章<小议如何在 Applet 中显示图象>的代码稍微改动一点就可以在application中显示
图象了，连附例程如下：
import javax.swing.*;
import java.awt.*;
import java.net.URL;
import java.awt.image.*;
public class MyFrame extends JFrame {
int xpoint = 100, ypoint = 100;
public MyFrame() {
//Do frame stuff.
super("MyFrame");
}
public void paint(Graphics g) {
URL imgURL = getClass().getResource("img/test.gif");
ImageIcon icon = new ImageIcon(imgURL);
g.drawImage(icon.getImage(),xpoint,ypoint,this);
}
// main function
public static void main(String[] args) {
MyFrame frame = new MyFrame();
frame.pack();
frame.setVisible(true);
}
}
5 07, 2007
package com.borland.samples.welcome;/**
* Title:
* Description:
* Copyright: Copyright (c) 2001
* Company:
* @author
* @version 1.0
*/
import java.awt.*;
import java.awt.image.*;
import com.sun.image.codec.jpeg.*;
class ImageCanvas extends Canvas{
private Image image;
private Dimension prefSize;
public ImageCanvas(Image image){
this.image = image;
calculatePreferredSize();
}
public void setImage(Image image){
this.image = image;
calculatePreferredSize();
repaint();
}
private void calculatePreferredSize(){
prefSize = new Dimension(image.getWidth(this),image.getHeight(this));
System.out.println(image.getWidth(this));
setSize(prefSize);
}
public Dimension getPreferredSize() {
return prefSize;
}
public Dimension getMinimumSize() {
return prefSize;
}
public void update(Graphics g){
paint(g);
}
public void paint(Graphics g){
g.drawImage(image,0,0,null);
}
}
class ImageUtils{
public static Image getScreenImage(){
Robot robot;
try {
robot = new Robot();
}catch(Exception e) {
throw new RuntimeException("unable to construct Robot");
}
Dimension screenDims =Toolkit.getDefaultToolkit().getScreenSize();
Image screen =robot.createScreenCapture(new Rectangle(450,350,screenDims.width,screenDims.height)).getScaledInstance(400,300,Image.SCALE_SMOOTH);
MediaTracker tracker =new MediaTracker(new Label());
tracker.addImage(screen,1);
try {
tracker.waitForID(0);
}catch(InterruptedException e) { /** ... */ }
return screen;
}
}
public class ScreenCapture extends Frame{
private ImageCanvas canvas =new ImageCanvas(ImageUtils.getScreenImage());
public ScreenCapture(){
add(canvas);
setSize(400,300);
setVisible(true);
Thread imageThread =new UpdateThread();
imageThread.setDaemon(true);
imageThread.start();
}
class UpdateThread extends Thread{
public void run(){
while(true){
try {
Thread.currentThread().sleep(1000);
}
catch (Exception ex) {
}
canvas.setImage(ImageUtils.getScreenImage());
validate();
}
}
}
public static void main(String[] args){
new ScreenCapture();
}
}