Java多媒体编程应用

1. 声音文件的播放

1.1 在Applet中播放声音

在Applet中,可以使用AudioClip来播放声音,它非常简单,只有三个方法:play()、loop()和stop()。

例1.1 利用AudioClip播放声音文件。

package duomeiti;

import java.applet.Applet;
import java.applet.AudioClip;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;

public class playMusic extends Applet implements ActionListener {
    AudioClip clip = null;
    JButton playBtn,loopBtn,stopBtn;
    public void init(){
        playBtn = new JButton("播放");
        loopBtn = new JButton("循环");
        stopBtn = new JButton("停止");
        playBtn.addActionListener(this);
        loopBtn.addActionListener(this);
        stopBtn.addActionListener(this);
        add(playBtn);
        add(loopBtn);
        add(stopBtn);
        clip = getAudioClip(getCodeBase(),"test.wav");
    }

    public void actionPerformed(ActionEvent e) {
        if(e.getSource()==playBtn)
            clip.play();
        else if(e.getSource()==loopBtn)
            clip.loop();
        else
            clip.stop();
    }
}

1.2 在Application中播放声音

它的一般用法是,先用AudioStream创建一个音频流对象,而后将此对象作为参数传递给AudioPlayer.player.start()方法以便播放。虽然AudioPlayer.player中只有start()和stop()两个方法,但是start()方法会从音频流对象上次停止播放的位置开始播放,而不是从头开始播放。所以用stop()暂停一个音频流的播放后,可以使用start()继续播放。

例1.2 在Application中播放声音文件。

package duomeiti;

import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.HeadlessException;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

import javax.swing.*;

import sun.audio.AudioPlayer;
import sun.audio.AudioStream;
public class playAudio implements ActionListener {
    protected JTextField fileField;
    protected JButton openBtn,startBtn,pauseBtn,resumBtn,stopBtn;
    protected Container con;
    protected JFrame jf;
    protected AudioStream as;
    protected FileInputStream fis;

    public playAudio(){
        jf = new JFrame("播放声音");
        con = jf.getContentPane();
        con.setLayout(new FlowLayout());
        fileField = new JTextField();
        fileField.setColumns(30);
        openBtn = new JButton("选择文件");
        startBtn = new JButton("开始播放");
        pauseBtn = new JButton("暂停播放");
        resumBtn = new JButton("继续播放");
        stopBtn = new JButton("停止播放");
        openBtn.addActionListener(this);
        startBtn.addActionListener(this);
        pauseBtn.addActionListener(this);
        resumBtn.addActionListener(this);
        stopBtn.addActionListener(this);
        con.add(fileField);
        con.add(openBtn);
        con.add(startBtn);
        con.add(pauseBtn);
        con.add(resumBtn);
        con.add(stopBtn);
        jf.setSize(500, 400);
        jf.setLocation(300, 200);
        jf.setVisible(true);
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }

    public void actionPerformed(ActionEvent e) {
        Object obj;
        obj = e.getSource();
        try {
            if(obj==openBtn)
                openfile();
            else if(obj==startBtn){
                if(fis!=null) fis.close();
                fis = new FileInputStream(fileField.getText());
                as = new AudioStream(fis);
                AudioPlayer.player.start(as);
            }else if(obj==pauseBtn)
                AudioPlayer.player.stop(as);
            else if(obj==resumBtn)
                AudioPlayer.player.start(as);
            else if(obj==stopBtn){
                AudioPlayer.player.stop(as);
                as.close();
                fis.close();
                fis = null;
            }
        } catch (FileNotFoundException e1) {
            JOptionPane.showMessageDialog(jf, "文件没有找到!");
        } catch (IOException e1) {
            JOptionPane.showMessageDialog(jf, "无法播放文件!");
        }
    }

    private void openfile() {
        try {
            JFileChooser chooser = new JFileChooser();
            if(chooser.showOpenDialog(jf)==JFileChooser.APPROVE_OPTION)
                fileField.setText(chooser.getSelectedFile().toString());
        } catch (Exception e) {
            JOptionPane.showMessageDialog(jf, "无法加载文件!");
        }
    }

    public static void main(String[] args) {
        new playAudio();
    }
}

 2. 基本图形处理

2.1 图形的缩放

例2.1 缩放图形示例

package duomeiti;
import java.awt.Color;
import java.awt.Graphics;

import javax.swing.*;
public class ResizeOval {
    JFrame jf;
    MyCanvas palette;
    public class MyCanvas extends JPanel{
        protected void paintComponent(Graphics g) {
            int height,width;
            height = getHeight();
            width = getWidth();
            g.setColor(Color.RED);
            g.fillOval(0, 0, width, height);
        }
    }

    public ResizeOval(){
        jf = new JFrame("图形缩放示例");
        palette = new MyCanvas();
        jf.getContentPane().add(palette);
        jf.setSize(500, 400);
        jf.setLocation(300,200);
        jf.setVisible(true);
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
    public static void main(String[] args) {
        new ResizeOval();
    }
}

2.2 淡入淡出效果

要实现淡入淡出效果方法非常简单,只要采用HSB(色调-饱和度-亮度)模式设置色彩,其中的色调和亮度不必变化,只要调整饱和度的值即可。如果是淡入,则让饱和度逐步增加;如果是淡出,则让饱和度逐步减少。

例2.2 淡入淡出效果示例。

package duomeiti;
import java.awt.Color;
import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.*;
public class fadeInOut {
    JFrame jf;
    JPanel jp;
    Container con;
    dealPushBtn handleBtn;
    JButton btn;

    public class dealPushBtn implements ActionListener{
        public void actionPerformed(ActionEvent e) {
            Graphics g = jp.getGraphics();
            float h = 0.0f;
            float s = 0.0f;
            float b = 1.0f;
            for(int i=0;i<100;i++){
                g.setColor(Color.getHSBColor(h, s, b));
                g.fillRect(0, 50, 300, 300);
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e1) {
                    e1.printStackTrace();
                }
                s+=0.01;
            }
            for(int i=0;i<100;i++){
                g.setColor(Color.getHSBColor(h, s, b));
                g.fillRect(0, 50, 300, 300);
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e1) {
                    e1.printStackTrace();
                }
                s-=0.01;
            }
        }
    }

    public fadeInOut(){
        jf = new JFrame("色彩淡入淡出示例");
        jp = new JPanel();
        jp.setLayout(new FlowLayout());
        handleBtn = new dealPushBtn();
        btn= new JButton("开始");
        btn.addActionListener(handleBtn);
        con = jf.getContentPane();
        jp.add(btn);
        con.add(jp);
        jf.setSize(300, 300);
        jf.setLocation(300, 200);
        jf.setVisible(true);
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
    public static void main(String[] args) {
        new fadeInOut();

    }

}

2.3  透明效果

设置前景色的透明度,可以使得前景色和后景色能够混合起来,这需要使用Graphics2D类。

例2.3 色彩混合效果示例。

package duomeiti;
import java.awt.AlphaComposite;
import java.awt.Color;
import java.awt.Composite;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Rectangle;

import javax.swing.*;
public class TransparencyExample extends JPanel {
    private static int gap=10, width=40, offset=10,deltax=gap+width+offset;
    private Rectangle blueSquare = new Rectangle(gap+offset,gap+offset,width,width),
            redSquare = new Rectangle(gap,gap,width,width);
    //创建一个指定alpha值的AlphaComposite对象
    private AlphaComposite makeComposite(float alpha){
        int type = AlphaComposite.SRC_OVER;
        return (AlphaComposite.getInstance(type, alpha));
    }
    //用指定的alpha值来绘制前景色
    private void drawSquares(Graphics2D g2d,float alpha){
        Composite originalComposite = g2d.getComposite();
        //用默认透明度绘制背景蓝色
        g2d.setPaint(Color.blue);
        g2d.fill(blueSquare);
        //设置透明度,准备绘制前景红色
        g2d.setComposite(makeComposite(alpha));
        g2d.setPaint(Color.red);
        g2d.fill(redSquare);
        //将透明度设置回默认的模式
        g2d.setComposite(originalComposite);
    }
    //分别用不同的透明度来绘制颜色
    public void paintComponent(Graphics g){
        super.paintComponent(g);
        Graphics2D g2d = (Graphics2D)g;
        for(int i=0;i<11;i++){
            //alpha值逐步增大,透明度逐步减小
            drawSquares(g2d,i*0.1F);
            g2d.translate(deltax, 0);
        }
    }
}
package duomeiti;
import javax.swing.*;
import java.awt.*;
public class mixing {
    JFrame jf;
    TransparencyExample palette;
    public mixing(){
        jf = new JFrame("色彩混合示例");
        palette = new TransparencyExample();
        jf.getContentPane().add(palette);
        jf.setSize(700, 400);
        jf.setLocation(300, 200);
        jf.setVisible(true);
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
    public static void main(String[] args) {
        new mixing();
    }
}

3. 字体的处理

3.1 确定可用字体

例3.1 获取系统中安装的字体示例。

package duomeiti;
import java.awt.GraphicsEnvironment;

import javax.swing.*;
public class GetFonts {
    private JFrame jf;
    private JList nameList;
    private JScrollPane nameSPane;
    public GetFonts(){
        jf = new JFrame("获取系统字体");
        //获得GraphicsEnvironment类型的对象引用
        GraphicsEnvironment eq = GraphicsEnvironment.getLocalGraphicsEnvironment();
        //获取所有的字体家族名
        String[] availableFonts = eq.getAvailableFontFamilyNames();
        //存放到列表框中
        nameList = new JList(availableFonts);
        nameSPane = new JScrollPane(nameList);
        jf.add(nameSPane);
        jf.setSize(500, 400);
        jf.setLocation(300, 200);
        jf.setVisible(true);
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
    public static void main(String[] args) {
        new GetFonts();
    }
}

3.2 创建字体对象

例3.2 创建和使用字体示例。

package duomeiti;
import javax.swing.*;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class ShowFonts implements ActionListener {
    private JFrame jf;
    private JComboBox nameBox,styleBox;
    private JTextField sizeText;
    private JLabel fontLabel;
    private JButton showBtn;
    private JPanel panel;

    public ShowFonts(){
        jf = new JFrame("显示指定字体");
        //显示系统可用字体
        GraphicsEnvironment eq = GraphicsEnvironment.getLocalGraphicsEnvironment();
        String[] availableFonts = eq.getAvailableFontFamilyNames();
        nameBox = new JComboBox(availableFonts);
        nameBox.setEditable(true);
        nameBox.setSelectedItem("宋体");
        //显示字体风格由用户选择
        String[] style = {"正常","粗体","斜体","粗斜体"};
        styleBox = new JComboBox(style);
        styleBox.setEditable(false);
        //由用户输入想要的字体尺寸
        sizeText = new JTextField("12");
        sizeText.setColumns(4);
        //标签用于显示用户选择的字体
        fontLabel = new JLabel("字体示例");
        //创建按钮并安装监听器
        showBtn = new JButton("显示字体");
        showBtn.addActionListener(this);
        //在窗口中排列组件
        panel = new JPanel();
        panel.setLayout(new FlowLayout());
        panel.add(nameBox);
        panel.add(styleBox);
        panel.add(sizeText);
        jf.add(panel, BorderLayout.NORTH);
        jf.add(fontLabel, BorderLayout.CENTER);
        jf.add(showBtn, BorderLayout.SOUTH);
        jf.setSize(500, 400);
        jf.setLocation(300, 200);
        jf.setVisible(true);
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }

    public void actionPerformed(ActionEvent e) {
        //分别获取用户选择输入的字体信息
        int styleIndex = styleBox.getSelectedIndex();
        String fontStr = (String)nameBox.getSelectedItem();
        int fontSize = Integer.parseInt(sizeText.getText());
        //组合字体对象
        Font userFont = new Font(fontStr,styleIndex,fontSize);
        //为标签设置新的字体并显示
        fontLabel.setFont(userFont);

    }

    public static void main(String[] args) {
        new ShowFonts();
    }
}

4. 字体的展示处理

例4.1 自行管理字体示例。

package duomeiti;
import javax.swing.*;
import java.awt.*;
public class FontsCanvas extends JPanel {
    private String msg;
    public FontsCanvas(String s){
        msg = s;
        setBackground(Color.white);
    }

    public FontsCanvas(){
        this("自行管理字体示例");
    }

    public void paintComponent(Graphics g){
        int maxWidth = getWidth(); //获取画布的宽度
        int showX; //文字输出的横坐标位置
        int showY = 0; //文字输出的纵坐标位置
        int descent = 0; //文字下半部所占位置
        int ascent = 0; //文字上半部所占位置
        int leading = 0; //行间距
        int totalWidth; //字符串所占宽度
        FontMetrics fm; //用于自行管理字体
        Font myFonts [] = new Font[4];
        //创建不同的字体准备显示
        myFonts[0] = new Font("宋体",Font.PLAIN,12);
        myFonts[1] = new Font("仿宋",Font.BOLD,24);
        myFonts[2] = new Font("黑体",Font.ITALIC,48);
        myFonts[3] = new Font("楷体_GB2312",Font.ITALIC|Font.BOLD,60);
        //用上述4种不同的字体显示同一个字符串,右对齐
        for(int i=0;i<myFonts.length;i++){
            g.setFont(myFonts[i]);
            fm = g.getFontMetrics();
            totalWidth = fm.stringWidth(msg);
            showX = maxWidth - totalWidth;
            ascent = fm.getMaxAscent();
            showY = showY + descent + ascent + leading;
            descent = fm.getMaxDescent();
            leading = fm.getLeading();
            g.drawString(msg, showX, showY);
        }
    }
}
package duomeiti;
import javax.swing.*;
import java.awt.*;
public class ManageFonts {
    private JFrame jf;
    private FontsCanvas palette; //可以显示多种文字的画布
    public ManageFonts(){
        jf = new JFrame("自行管理字体示例");
        palette = new FontsCanvas();
        jf.add(palette);
        jf.setSize(500, 400);
        jf.setLocation(300, 200);
        jf.setVisible(true);
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }

    public static void main(String[] args) {
        new ManageFonts();
    }
}

5. 字体的特效显示

例5.1 字体特效显示示例。

package duomeiti;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Container;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Timer;
import java.util.TimerTask;

import javax.swing.*;
public class LightingLiteral implements ActionListener {
    String title = "光照文字";    //显示的文字
    Font myFont = new Font("宋体",Font.BOLD,48); //显示的字体
    JPanel palette;
    JFrame jf;
    JButton startBtn;
    Container con;
    Timer myTimer;
    Refresh task;
    boolean startFlag;
    public LightingLiteral(){
        jf = new JFrame(title);
        palette = new JPanel();
        startBtn = new JButton("开始");
        startFlag = true;
        startBtn.addActionListener(this);
        con = jf.getContentPane();
        con.add(palette, BorderLayout.CENTER);
        con.add(startBtn, BorderLayout.NORTH);
        jf.setSize(500, 400);
        jf.setLocation(300, 200);
        jf.setVisible(true);
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }

    public void actionPerformed(ActionEvent e) {
        if(startFlag){
            myTimer = new Timer();
            task = new Refresh();
            myTimer.schedule(task, 50, 50);  //启动定时器,时间间隔为50毫秒
            startBtn.setText("停止");
        }else{
            myTimer.cancel();
            myTimer = null;
            task = null;
            startBtn.setText("开始");
        }
        startFlag = !startFlag;
    }

    //用定时器来绘图
    class Refresh extends TimerTask{
        int pos = 0;
        int blink_width = 20;                //光条的宽度
        Graphics g = palette.getGraphics();  //注意画笔的获取方式
        FontMetrics myFM = g.getFontMetrics(myFont);
        int height = myFM.getHeight();  //计算文字的高度
        int top = myFM.getAscent();
        int width = myFM.stringWidth(title);
        public Refresh(){
            g.setFont(myFont);
        }
        public void run() {
            g.setColor(Color.blue);
            g.drawString(title, 0, top);  //第一遍显示
            g.clipRect(pos, 0, blink_width, height);  //设置裁剪区域
            g.setColor(Color.yellow);
            g.drawString(title, 0, top);  //第二遍显示,它只会显示在裁剪区域中
            pos = (pos + 5) % width;  //移动裁剪区域的位置
            g.setClip(null);  //让裁剪区域失效,准备重新绘制蓝色文字
        }
    }

    public static void main(String[] args) {
        new LightingLiteral();
    }
}
时间: 2024-10-10 14:46:08

Java多媒体编程应用的相关文章

Android的多媒体编程

多媒体编程 1.什么是多媒体? 多种媒体的综合. 图片.音乐.视频等: ##图片的常见格式: 1.bmp:以高质量保存所有类型的图片,并将其应用于计算机: 255 KB,255*340像素,24位深度 计算机表示图形的时候时候是使用像素点来表示的,每个像素点都有一个颜色,每个颜色都是使用6位16进制的数值来表示的,一个像素点使用24个bit表示. 图像大小的计算公式:分辨率的宽*高*位深度 + 头文件占用的数据大小=图形实际大小 ,颜色不会失真,图片的体积比较大. 2.jpg:36.4 KB,2

Java并发编程:Concurrent锁机制解析

.title { text-align: center } .todo { font-family: monospace; color: red } .done { color: green } .tag { background-color: #eee; font-family: monospace; padding: 2px; font-size: 80%; font-weight: normal } .timestamp { color: #bebebe } .timestamp-kwd

Java核心编程快速学习

Java核心编程部分的基础学习内容就不一一介绍了,本文的重点是JAVA中相对复杂的一些概念,主体内容如下图所示. 反射reflect是理解Java语言工作原理的基础,Java编译器首先需要将我们编写的.java源文件编译为.class字节码,然后再JVM虚拟机上运行,接下来通过一个表格,来了解反射的基本操作. 功能 示例 泛化的Class引用 Class<?> intClass = int.class Class<? extends Number> bounded = int.cl

Java并发编程:Callable、Future和FutureTask(转)

Java并发编程:Callable.Future和FutureTask 在前面的文章中我们讲述了创建线程的2种方式,一种是直接继承Thread,另外一种就是实现Runnable接口. 这2种方式都有一个缺陷就是:在执行完任务之后无法获取执行结果. 如果需要获取执行结果,就必须通过共享变量或者使用线程通信的方式来达到效果,这样使用起来就比较麻烦. 而自从Java 1.5开始,就提供了Callable和Future,通过它们可以在任务执行完毕之后得到任务执行结果. 今天我们就来讨论一下Callabl

Java并发编程 Volatile关键字解析

volatile关键字的两层语义 一旦一个共享变量(类的成员变量.类的静态成员变量)被volatile修饰之后,那么就具备了两层语义: 1)保证了不同线程对这个变量进行操作时的可见性,即一个线程修改了某个变量的值,这新值对其他线程来说是立即可见的. 2)禁止进行指令重排序. 根据volatile的语义,我们可以看到,volatile主要针对的是并发三要素(原子性,可见性和有序性)中的后两者有实际优化作用. 可见性: 线程本身并不直接与主内存进行数据的交互,而是通过线程的工作内存来完成相应的操作.

第14篇-JAVA GUI编程

第14篇-JAVA GUI编程 每篇一句 :道路一开始开辟的时候总是存在障碍的 初学心得: 原本下定决心才能开始的事情也变得理所当然 (笔者:JEEP/711)[JAVA笔记 | 时间:2017-04-25| JAVA GUI编程 ] 1.什么是界面 图形用户界面(Graphical User Interface,简称 GUI,又称图形用户接口)是指采用图形方式显示的计算机操作用户界面 与早期计算机使用的命令行界面相比,图形界面对于用户来说在视觉上更易于接受 2.Java 基础类 JFC 的基本

Java并发编程

synchronized是Java中的关键字,在并发编程中被称为内置锁或者监视器锁.当用它来修饰一个方法或者一个代码块的时候能够保证同一时刻最多只有一个线程执行该段代码. Java的内置锁相当于一种互斥锁,最多只有一个线程能够持有这种锁,故而由这个锁保护的同步代码块会以原子方式执行,多个线程在执行该代码时就不会相互干扰. 但由于被锁保护的同步块代码是以串行形式来访问的,即多个线程以独占的方式访问对象,而这也导致如果被锁保护的同步代码块的作用范围过大,会导致并发不良. 这里有必要简单讲一下内置锁的

《Java面向对象编程第二版》今年出版以来获得读者一致好评。

<Java面向对象编程第一版>自2016年出版以来,承蒙读者们的厚爱,至今已经重印了二十多次,成为国内Java领域里的经典Java技术宝典.在当当网上获得了1500多条好评: http://product.dangdang.com/9186890.html?point=comment_point 应广大读者的要求,为第一版进行了升级,第二版融合了最新的Java8的语言特性,它继续为Java开发人员们提供丰富全面的技术支持和帮助.在京东网上读者们对第二版的好评如潮,一致认为这是Java开发人员必

6、Java并发编程:volatile关键字解析

Java并发编程:volatile关键字解析 volatile这个关键字可能很多朋友都听说过,或许也都用过.在Java 5之前,它是一个备受争议的关键字,因为在程序中使用它往往会导致出人意料的结果.在Java 5之后,volatile关键字才得以重获生机. volatile关键字虽然从字面上理解起来比较简单,但是要用好不是一件容易的事情.由于volatile关键字是与Java的内存模型有关的,因此在讲述volatile关键之前,我们先来了解一下与内存模型相关的概念和知识,然后分析了volatil