疯狂java实战演义 弹球游戏代码

package org.crazyit.ball;

import java.awt.Image;
import java.io.File;
import javax.imageio.ImageIO;
import java.io.IOException;

/**
 * 小球对象
 * 
 * @author yangenxiong yangenxiong2009@gmail.com
 * @author Kelvin Mak kelvin.mak125@gmail.com
 * @version  1.0
 * <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
 * <br>Copyright (C), 2009-2010, yangenxiong
 * <br>This program is protected by copyright laws.
 */
public class Ball extends BallComponent {
    // 定义球的竖向速度
    private int speedY = 10;
    // 定义弹球的横向速度
    private int speedX = 8;
    // 定义是否在运动
    private boolean started = false;
    // 定义是否结束运动
    private boolean stop = false;

    /**
     * m 有参数构造器
     * 
     * @param panelWidth
     *            int 画板宽度
     * @param panelHeight
     *            int 画板高度
     * @param offset
     *            int 位移
     * @param path
     *            String 图片路径
     */
    public Ball(int panelWidth, int panelHeight, int offset, String path)
            throws IOException {
        // 调用父构造器
        super(panelWidth, panelHeight, path);
        // 设置y坐标
        this.setY(panelHeight - super.getImage().getHeight(null) - offset);
    }

    /**
     * 设置横向速度
     * 
     * @param speed
     *            int 速度
     * @return void
     */
    public void setSpeedX(int speed) {
        this.speedX = speed;
    }

    /**
     * 设置竖向速度
     * 
     * @param speed
     *            int 速度
     * @return void
     */
    public void setSpeedY(int speed) {
        this.speedY = speed;
    }

    /**
     * 设置是否在运动
     * 
     * @param b
     *            boolean
     * @return void
     */
    public void setStarted(boolean b) {
        this.started = b;
    }

    /**
     * 设置是否结束运动
     * 
     * @param b
     *            boolean
     * @return void
     */
    public void setStop(boolean b) {
        this.stop = b;
    }

    /**
     * 返回横向速度
     * 
     * @return int 速度
     */
    public int getSpeedX() {
        return this.speedX;
    }

    /**
     * 返回竖向速度
     * 
     * @return int 速度
     */
    public int getSpeedY() {
        return this.speedY;
    }

    /**
     * 是否在运动
     * 
     * @return boolean 是否在运动
     */
    public boolean isStarted() {
        return this.started;
    }

    /**
     * 是否已经结束运动
     * 
     * @return boolean 是否已经结束运动
     */
    public boolean isStop() {
        return this.stop;
    }

}

package org.crazyit.ball;

import java.awt.Image;
import java.io.File;
import javax.imageio.ImageIO;
import java.io.IOException;

/**
 * 桌面弹球游戏相关组件的父类
 * 
 * @author yangenxiong yangenxiong2009@gmail.com
 * @author Kelvin Mak kelvin.mak125@gmail.com
 * @version  1.0
 * <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
 * <br>Copyright (C), 2009-2010, yangenxiong
 * <br>This program is protected by copyright laws.
 */
public class BallComponent {
    // 设置x坐标
    private int x = -1;
    // 设置y坐标
    private int y = -1;
    // 设置图片
    private Image image = null;
    // 设置图片速度
    private int speed = 5;

    /**
     * 构造器
     * 
     * @param path
     *            String 图片路径
     */
    public BallComponent(String path) throws IOException {
        super();
        this.image = ImageIO.read(new File(path));
    }

    /**
     * 构造器
     * 
     * @param panelWidth
     *            int 画板宽度
     * @param panelHeight
     *            int 画板高度
     * @param path
     *            String 图片路径
     */
    public BallComponent(int panelWidth, int panelHeight, String path)
            throws IOException {
        super();
        // 读取图片
        this.image = ImageIO.read(new File(path));
        // 设置x坐标
        this.x = (int) ((panelWidth - image.getWidth(null)) / 2);
    }

    /**
     * 构造器
     * 
     * @param x
     *            int 图像的x坐标
     * @param y
     *            int 图像的y坐标
     * @param path
     *            String 图片路径
     */
    public BallComponent(String path, int x, int y) throws IOException {
        super();
        // 读取图片
        this.image = ImageIO.read(new File(path));
        this.x = x;
        this.y = y;
    }

    /**
     * 获取x坐标
     * 
     * @return int x坐标
     */
    public int getX() {
        return this.x;
    }

    /**
     * 获取y坐标
     * 
     * @return int y坐标
     */
    public int getY() {
        return this.y;
    }

    /**
     * 获取图片速度
     * 
     * @return int 图片速度
     */
    public int getSpeed() {
        return this.speed;
    }

    /**
     * 设置x坐标
     * 
     * @param x
     *            int x坐标
     * @return void
     */
    public void setX(int x) {
        this.x = x;
    }

    /**
     * 设置y坐标
     * 
     * @param y
     *            int y坐标
     * @return void
     */
    public void setY(int y) {
        this.y = y;
    }

    /**
     * 返回图片
     * 
     * @return Image 图片
     */
    public Image getImage() {
        return this.image;
    }
}

package org.crazyit.ball;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;
import java.awt.Dimension;
import java.awt.Image;
import java.awt.Graphics;
import java.awt.Color;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyListener;
import java.awt.event.KeyEvent;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.io.IOException;

/**
 * 游戏界面
 * 
 * @author yangenxiong yangenxiong2009@gmail.com
 * @author Kelvin Mak kelvin.mak125@gmail.com
 * @version  1.0
 * <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
 * <br>Copyright (C), 2009-2010, yangenxiong
 * <br>This program is protected by copyright laws.
 */
public class BallFrame extends JFrame {
    // 定义JPanel的宽度
    private final int BALLPANEL_WIDTH = 307;
    // 定义JPanel的高度
    private final int BALLPANEL_HEIGHT = 400;
    // 定义画板
    private BallPanel ballPanel = null;
    // 定义档板
    // private Image stick = null;
    // 设置档板x坐标
    private int stickX = -1;
    // 创建一个BallService实例
    private BallService service = null;
    // 定义一个timer
    Timer timer = null;

    /**
     * 默认构造器
     */
    public BallFrame() throws IOException {
        super();
        // 初始化
        initialize();
    }

    /**
     * 初始化界面
     * 
     * @return void
     */
    public void initialize() throws IOException {
        // 设置窗口的标题
        this.setTitle("弹球");
        // 设置为不可改变大小
        this.setResizable(false);
        // 设置背景为黑色
        this.setBackground(Color.BLACK);
        // 获取画板
        ballPanel = getBallPanel();
        // 创建BallService实例
        service = new BallService(this, BALLPANEL_WIDTH, BALLPANEL_HEIGHT);

        // 定义每0.1秒执行一次监听器
        ActionListener task = new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                // 开始改变位置
                service.run();
                // 刷新画板
                ballPanel.repaint();
            }
        };
        // 如果timer不为空
        if (timer != null) {
            // 重新开始timer
            timer.restart();
        } else {
            // 新建一个timer
            timer = new Timer(100, task);
            // 开始timer
            timer.start();
        }

        this.add(ballPanel);
        // 增加事件监听器
        KeyListener[] klarr = this.getKeyListeners();
        if (klarr.length == 0) {
            // 定义键盘监听适配器
            KeyListener keyAdapter = new KeyAdapter() {
                public void keyPressed(KeyEvent ke) {
                    // 改变档板的坐标
                    service.setStickPos(ke);
                }
            };
            this.addKeyListener(keyAdapter);
        }
    }

    /**
     * 获取画板
     * 
     * @return BallPanel 返回BallPanle
     */
    public BallPanel getBallPanel() {

        if (ballPanel == null) {
            // 新建一个画板
            ballPanel = new BallPanel();
            // 设置画板的大小
            ballPanel.setPreferredSize(new Dimension(BALLPANEL_WIDTH,
                    BALLPANEL_HEIGHT));
        }
        return ballPanel;
    }

    // 定义一个JPanel内部类来完成画图功能
    public class BallPanel extends JPanel {
        /**
         * 重写void paint( Graphics g )方法
         * 
         * @param g
         *            Graphics
         * @return void
         */
        public void paint(Graphics g) {
            // 画图
            service.draw(g);
        }
    }

}

package org.crazyit.ball;

import java.io.IOException;

import javax.swing.JFrame;

/**
 * 游戏入口类
 * 
 * @author yangenxiong yangenxiong2009@gmail.com
 * @author Kelvin Mak kelvin.mak125@gmail.com
 * @version  1.0
 * <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
 * <br>Copyright (C), 2009-2010, yangenxiong
 * <br>This program is protected by copyright laws.
 */
public class BallGame {
    /**
     * 开始游戏
     * 
     * @return void
     */
    public static void main(String[] args) throws IOException {
        BallFrame ballFrame = new BallFrame();
        ballFrame.pack();
        ballFrame.setVisible(true);
        ballFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

package org.crazyit.ball;

import java.awt.event.KeyEvent;
import java.awt.Image;
import java.awt.Graphics;
import java.io.IOException;

/**
 * 处理游戏逻辑的对象
 * 
 * @author yangenxiong yangenxiong2009@gmail.com
 * @author Kelvin Mak kelvin.mak125@gmail.com
 * @version  1.0
 * <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
 * <br>Copyright (C), 2009-2010, yangenxiong
 * <br>This program is protected by copyright laws.
 */
public class BallService {
    // 定义一个Stick(档板)
    private Stick stick = null;
    // 定义一个弹球
    private Ball ball = null;
    // 定义一个游戏结束图片
    private BallComponent gameOver = null;
    // 定义一个赢了游戏的图片
    private BallComponent won = null;
    // 定义一个砖块图片数组
    private Brick[][] bricks = null;
    private int width;
    private int height;
    BallFrame ballFrame = null;

    /**
     * 私有空构造器
     */
    private BallService() {
        super();
    }

    /**
     * 
     * @param frame
     *            JFrame JFrame实例
     * @param width
     *            int 宽
     * @param height
     *            int 高
     * @return BallService
     */
    public BallService(BallFrame frame, int width, int height)
            throws IOException {
        // 初始化变量
        this.width = width;
        this.height = height;
        this.ballFrame = frame;
        // 创建一个Stick(档板)实例
        stick = new Stick(width, height, "img/stick.jpg");
        // 创建一个弹球的实例
        ball = new Ball(width, height, stick.getImage().getHeight(null),
                "img/ball.gif");
        // 游戏结束图片
        gameOver = new BallComponent("img/over.gif");
        // 赢图片
        won = new BallComponent("img/win.gif");
        // 砖块图片数组
        bricks = createBrickArr("img/brick.gif", 11, 6);
    }

    /**
     * run
     * 
     * @return void
     */
    public void run() {
        // 弹球坐标改变
        setBallPos();
        // 道具坐标改改变
        setMagicPos();
    }

    /**
     * 设置档板图片的位置
     * 
     * @param ke
     *            KeyEvent 键盘事件
     * @return void
     */
    public void setStickPos(KeyEvent ke) {
        // 把弹球的运动状态设为true
        ball.setStarted(true);
        // 如果是左方向键
        if (ke.getKeyCode() == KeyEvent.VK_LEFT) {
            if (stick.getX() - stick.SPEED > 0) {
                // x坐标向左移动
                stick.setX(stick.getX() - stick.SPEED);
            }
        }
        // 如果是右方向键
        if (ke.getKeyCode() == KeyEvent.VK_RIGHT) {
            if (stick.getX() + stick.SPEED < width - stick.getPreWidth()) {
                // x坐标向右移动
                stick.setX(stick.getX() + stick.SPEED);
                // ballFrame.getBallGame().reStart( ballFrame );
            }
        }
        // 如果是F2键
        if (ke.getKeyCode() == KeyEvent.VK_F2) {
            // 初始化ballFrame
            try {
                ballFrame.initialize();
            } catch (IOException e) {
                System.out.println(e.getMessage());
            }
        }
    }

    /**
     * 设置小球图片的位置
     * 
     * @return void
     */
    public void setBallPos() {
        // 正数的数度
        int absSpeedX = Math.abs(ball.getSpeedX());
        int absSpeedY = Math.abs(ball.getSpeedY());
        // 如果游戏已经开始而且没有结束
        if (ball.isStarted()) {
            // 如果小球碰到左边界
            if (ball.getX() - absSpeedX < 0) {
                // 重新设置x坐标
                ball.setX(ball.getImage().getWidth(null));
                // 把x方向的速度设为反方向
                ball.setSpeedX(-ball.getSpeedX());
            }
            // 如果小球碰到右边界
            if (ball.getX() + absSpeedX > width
                    - ball.getImage().getWidth(null)) {
                // 重新设置x坐标
                ball.setX(width - ball.getImage().getWidth(null) * 2);
                // 把x方向的速度设为反方向
                ball.setSpeedX(-ball.getSpeedX());
            }
            // 如果小球碰到上边界
            if (ball.getY() - absSpeedY < 0) {
                // 重新设置y坐标
                ball.setY(ball.getImage().getWidth(null));
                // 把y方向的速度设为反方向
                ball.setSpeedY(-ball.getSpeedY());
            }
            // 如果小球碰到下边界
            if (ball.getY() + absSpeedY > height
                    - stick.getImage().getHeight(null)) {
                // 如果小球与档板有碰撞
                if (isHitStick(ball)) {
                    // 重新设置y坐标
                    ball.setY(height - ball.getImage().getHeight(null) * 2);
                    // 把y方向的速度设为反方向
                    ball.setSpeedY(-ball.getSpeedY());
                }
            }
            // 与砖块碰撞后的运动
            for (int i = bricks.length - 1; i > -1; i--) {
                for (int j = bricks[i].length - 1; j > -1; j--) {
                    // 如果小球与砖块有碰撞
                    if (isHitBrick(bricks[i][j])) {
                        if (ball.getSpeedY() > 0) {
                            ball.setSpeedY(-ball.getSpeedY());
                        }
                    }
                }
            }
            // 结束游戏
            if (ball.getY() > height) {
                ball.setStop(true);
            }

            // 设置x坐标
            ball.setX(ball.getX() - (int) (Math.random() * 2)
                    - ball.getSpeedX());
            // 设置y坐标
            ball.setY(ball.getY() - (int) (Math.random() * 2)
                    - ball.getSpeedY());
        }
    }

    /**
     * 小球与砖块是否有碰撞
     * 
     * @return boolean
     */
    public boolean isHitBrick(Brick brick) {
        if (brick.isDisable()) {
            return false;
        }
        // ball的圆心x坐标
        double ballX = ball.getX() + ball.getImage().getWidth(null) / 2;
        // ball的圆心y坐标
        double ballY = ball.getY() + ball.getImage().getHeight(null) / 2;
        // brick的中心x坐标
        double brickX = brick.getX() + brick.getImage().getWidth(null) / 2;
        // brick的中心y坐标
        double brickY = brick.getY() + brick.getImage().getHeight(null) / 2;
        // 两个坐标点的距离
        double distance = Math.sqrt(Math.pow(ballX - brickX, 2)
                + Math.pow(ballY - brickY, 2));
        // 如果两个图形重叠，返回true;
        if (distance < (ball.getImage().getWidth(null) + brick.getImage()
                .getWidth(null)) / 2) {
            // 使brick无效
            brick.setDisable(true);
            return true;

        }
        return false;
    }

    /**
     * BallComponent是否与档板有碰撞
     * 
     * @param image
     *            BallComponent 图像
     * @return boolean
     */
    public boolean isHitStick(BallComponent bc) {
        // 获取图片对象
        Image tempImage = bc.getImage();
        // 如果与档板有碰撞
        if (bc.getX() + tempImage.getWidth(null) > stick.getX()
                && bc.getX() < stick.getX() + stick.getPreWidth()
                && bc.getY() + tempImage.getHeight(null) > stick.getY()) {
            return true;
        }
        return false;
    }

    /**
     * 设置道具的位置
     * 
     * @return void
     */
    public void setMagicPos() {
        for (int i = 0; i < bricks.length; i++) {
            for (int j = 0; j < bricks[i].length; j++) {
                // 获取magic
                Magic magic = bricks[i][j].getMagic();
                if (magic != null) {
                    // 如果这个brick的状态是无效的
                    if (bricks[i][j].isDisable() && magic.getY() < height) {
                        // 设置magic的y坐标向下增加
                        magic.setY(magic.getY() + magic.getSpeed());
                        // 设置档板的宽度
                        setStickWidth(magic);

                    }
                }
            }
        }
    }

    /**
     * 设置档板的长度
     * 
     * @param magic
     *            Magic 道具
     * @return void
     */
    public void setStickWidth(Magic magic) {
        if (isHitStick(magic)) {
            // 道具的作用
            magic.magicDo(stick);
        }
    }

    /**
     * 判断是否赢了
     * 
     * @return boolean
     */
    public boolean isWon() {
        // 如果消了全部砖块，则为赢
        for (int i = 0; i < bricks.length; i++) {
            for (int j = 0; j < bricks[i].length; j++) {
                if (!bricks[i][j].isDisable()) {
                    return false;
                }
            }
        }
        return true;
    }

    /**
     * 创建一个类型为Brick的数组
     * 
     * @param path
     *            String 图像路径
     * @param xSize
     *            int
     * @param ySize
     *            int
     * @return Brick[][]
     */
    public Brick[][] createBrickArr(String path, int xSize, int ySize)
            throws IOException {
        // 创建一个Brick[][]
        Brick[][] bricks = new Brick[xSize][ySize];
        int x = 0;
        int y = 0;
        int random = 0;
        int imageSize = 28;
        boolean isDisable = false;
        // 迭代初始化数组
        for (int i = 0; i < xSize; i++) {
            for (int j = 0; j < ySize; j++) {
                // 创建一个新的砖块
                random = (int) (Math.random() * 3);
                x = i * imageSize;
                y = j * imageSize;
                // 一定机率没有砖块
                isDisable = Math.random() > 0.8 ? true : false;
                if (isDisable) {
                    random = 0;
                }
                Brick brick = new Brick(path, random, x, y);
                brick.setDisable(isDisable);
                // 设置x坐标
                brick.setX(x);
                // 设置y坐标
                brick.setY(y);
                bricks[i][j] = brick;
            }
        }
        return bricks;
    }

    /**
     * 画图
     * 
     * @param g
     *            Graphics 用来画图的对象
     * @return void
     */
    public void draw(Graphics g) {
        // 如果赢了
        if (isWon()) {
            // 绘制赢的图片
            g.drawImage(won.getImage(), won.getX(), won.getY(), width,
                    height - 10, null);
        } else if (ball.isStop()) {
            // 绘制游戏结束图像
            g.drawImage(gameOver.getImage(), gameOver.getX(), gameOver.getY(),
                    width, height - 10, null);
        } else {
            // 清除原来的图像
            g.clearRect(0, 0, width, height);
            // 绘制档板图像
            g.drawImage(stick.getImage(), stick.getX(), stick.getY(), stick
                    .getPreWidth(), stick.getImage().getHeight(null), null);
            // 绘制弹球图像
            g.drawImage(ball.getImage(), ball.getX(), ball.getY(), null);
            // 迭代绘制砖块图像
            for (int i = 0; i < bricks.length; i++) {
                for (int j = 0; j < bricks[i].length; j++) {
                    BallComponent magic = bricks[i][j].getMagic();
                    // 如果这个砖块图像对像是有效的
                    if (!bricks[i][j].isDisable()) {
                        // 里面的数字1为砖块图像间的间隙
                        g.drawImage(bricks[i][j].getImage(), bricks[i][j]
                                .getX(), bricks[i][j].getY(), bricks[i][j]
                                .getImage().getWidth(null) - 1, bricks[i][j]
                                .getImage().getHeight(null) - 1, null);
                    } else if (magic != null && magic.getY() < height) {
                        g.drawImage(magic.getImage(), magic.getX(), magic
                                .getY(), null);
                    }
                }
            }
        }
    }
}

package org.crazyit.ball;

import java.awt.Image;
import java.io.IOException;

/**
 * 砖块类
 * 
 * @author yangenxiong yangenxiong2009@gmail.com
 * @author Kelvin Mak kelvin.mak125@gmail.com
 * @version  1.0
 * <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
 * <br>Copyright (C), 2009-2010, yangenxiong
 * <br>This program is protected by copyright laws.
 */
public class Brick extends BallComponent {

    // 定义道具
    private Magic magic = null;
    // 定义一个boolean变量设置本类是否有效
    private boolean disable = false;
    public static final int MAGIC_LONG_TYPE = 1;
    public static final int MAGIC_SHORT_TYPE = 2;

    /**
     * 构造器
     * 
     * @return void
     */
    public Brick(String path, int type, int x, int y) throws IOException {
        super(path);
        if (type == Brick.MAGIC_LONG_TYPE) {
            this.magic = new LongMagic("img/long.gif", x, y);
        } else if (type == Brick.MAGIC_SHORT_TYPE) {
            this.magic = new ShortMagic("img/short.gif", x, y);
        }
        if (this.magic != null) {
            this.magic.setX(x);
            this.magic.setY(y);
        }
    }

    /**
     * 设置本类有没有效
     * 
     * @param disable
     *            boolean
     * @return void
     */
    public void setDisable(boolean disable) {
        this.disable = disable;
    }

    /**
     * 查看本类有没有效
     * 
     * @return boolean 是否有效
     */
    public boolean isDisable() {
        return this.disable;
    }

    /**
     * 获取道具
     * 
     * @return String magic
     */
    public Magic getMagic() {
        return this.magic;
    }

    /**
     * 设置道具
     * 
     * @return String magic
     */
    public void setMagic(Magic magic) {
        this.magic = magic;
    }
}

package org.crazyit.ball;

import java.io.IOException;

/**
 * 道具对象
 * 
 * @author yangenxiong yangenxiong2009@gmail.com
 * @author Kelvin Mak kelvin.mak125@gmail.com
 * @version  1.0
 * <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
 * <br>Copyright (C), 2009-2010, yangenxiong
 * <br>This program is protected by copyright laws.
 */
public abstract class Magic extends BallComponent {
    /**
     * 提供给子类调用的构造器
     * 
     * @param path
     *            String 文件路径
     * @param x
     *            int x坐标
     * @param y
     *            int y坐标
     */
    public Magic(String path, int x, int y) throws IOException {
        super(path, x, y);
    }

    /**
     * 道具的功能
     * 
     * @param stitck
     *            Stick
     * @return void
     */
    public abstract void magicDo(Stick stick);
}

package org.crazyit.ball;

import java.io.IOException;

/**
 * 使挡板变长的道具
 * 
 * @author yangenxiong yangenxiong2009@gmail.com
 * @author Kelvin Mak kelvin.mak125@gmail.com
 * @version  1.0
 * <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
 * <br>Copyright (C), 2009-2010, yangenxiong
 * <br>This program is protected by copyright laws.
 */
public class LongMagic extends Magic {
    /**
     * 构造器
     * 
     * @param path
     *            String 文件路径
     * @param x
     *            int x坐标
     * @param y
     *            int y坐标
     */
    public LongMagic(String path, int x, int y) throws IOException {
        super(path, x, y);
    }

    /**
     * 道具的功能 : 档板变长
     * 
     * @param stitck
     *            Stick
     * @return void
     */
    public void magicDo(Stick stick) {
        double imageWidth = stick.getImage().getWidth(null);
        // 如果档板没有变长过
        if (stick.getPreWidth() <= imageWidth) {
            // 将档板的长度改为双倍
            stick.setPreWidth((int) (stick.getPreWidth() * 2));
        }
    }
}

package org.crazyit.ball;

import java.io.IOException;

/**
 * 使挡板变短的道具
 * 
 * @author yangenxiong yangenxiong2009@gmail.com
 * @author Kelvin Mak kelvin.mak125@gmail.com
 * @version  1.0
 * <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
 * <br>Copyright (C), 2009-2010, yangenxiong
 * <br>This program is protected by copyright laws.
 */
public class ShortMagic extends Magic {
    /**
     * 构造器
     * 
     * @param path
     *            String 文件路径
     * @param x
     *            int x坐标
     * @param y
     *            int y坐标
     */
    public ShortMagic(String path, int x, int y) throws IOException {
        super(path, x, y);
    }

    /**
     * 道具的功能 : 档板变短
     * 
     * @param stitck
     *            Stick
     * @return void
     */
    public void magicDo(Stick stick) {
        double imageWidth = stick.getImage().getWidth(null);
        // 如果档板没有变短过
        if (stick.getPreWidth() >= imageWidth) {
            // 将档板的宽度改为一半
            stick.setPreWidth((int) (stick.getPreWidth() * 0.5));
        }
    }
}

package org.crazyit.ball;

import java.io.IOException;

/**
 * 挡板类
 * 
 * @author yangenxiong yangenxiong2009@gmail.com
 * @author Kelvin Mak kelvin.mak125@gmail.com
 * @version  1.0
 * <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
 * <br>Copyright (C), 2009-2010, yangenxiong
 * <br>This program is protected by copyright laws.
 */
public class Stick extends BallComponent {
    // 定义档板移动的速度
    public static final int SPEED = 20;
    // 定义档板初始的长度
    private int preWidth = 0;

    /**
     * 有参数构造器
     * 
     * @param panelWidth
     *            int 画板宽度
     * @param panelHeight
     *            int 画板高度
     * @param path
     *            String 图片路径
     */
    public Stick(int panelWidth, int panelHeight, String path)
            throws IOException {
        // 调用父构造器
        super(panelWidth, panelHeight, path);
        // 设置y坐标
        this.setY(panelHeight - super.getImage().getHeight(null));
        // 设置原本的长度
        this.preWidth = super.getImage().getWidth(null);
    }

    /**
     * 获取初始长度
     * 
     * @return int 初始长度
     */
    public int getPreWidth() {
        return this.preWidth;
    }

    /**
     * 设置初始长度
     * 
     * @return void
     */
    public void setPreWidth(int preWidth) {
        this.preWidth = preWidth;
    }

}