锐客网

  1. 首页 > 睿知 > it技术 > >

打鸭子游戏的java代码 打鸭子游戏的java代码怎么写

IT技术public

JAVA小游戏程序代码这个是比较有名的那个烟花，不知道你有没有用：
建个工程，以Fireworks为类即可
import java.awt.*;
import java.applet.*;
import java.awt.event.*;
import javax.swing.*;
public class Fireworks extends Applet implements MouseListener,Runnable
{
int x,y;
int top,point;
/**
*对小程序进行变量和颜色的初始化 。
*/
public void init()
{
x = 0;
y = 0;
//设置背景色为黑色
setBackground(Color.black);
addMouseListener(this);
}
public void paint(Graphics g)
{
}
/**
*使该程序可以作为应用程序运行 。
*/
public static void main(String args[]) {
Fireworks applet = new Fireworks();
JFrame frame = new JFrame("TextAreaNew");
frame.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e){
System.exit(0);
}
});
frame.getContentPane().add(
applet, BorderLayout.CENTER);
frame.setSize(800,400);
applet.init();
applet.start();
frame.setVisible(true);
}
/**
*程序主线程，对一个烟花进行绘制 。
*/
public void run()
{
//变量初始化
Graphics g1;
g1 = getGraphics();
int y_move,y_click,x_click;
int v;
x_click = x;
y_click = y;
y_move = 400;
v = 3;
int r,g,b;
while(y_movey_click)
{
g1.setColor(Color.black);
g1.fillOval(x_click,y_move,5,5);
y_move -= 5;
r = (((int)Math.round(Math.random()*4321)) 0) 55;
g = (((int)Math.round(Math.random()*4321)) 0) 55;
b = (((int)Math.round(Math.random()*4321)) 0) 55;
g1.setColor(new Color(r,g,b));
g1.fillOval(x_click,y_move,5,5);
for(int j = 0 ;j=10;j)
{
if(r55) r -= 20;
if(g55) g -= 20;
if(b55) b -=20;
g1.setColor(new Color(r,g,b));
g1.fillOval(x_click,y_move j*5,5,5);
}
g1.setColor(Color.black);
g1.fillOval(x_click,y_move 5*10,5,5);
try
{
Thread.currentThread().sleep(v);
} catch (InterruptedException e) {}
}
for(int j=12;j=0;j--)
{
g1.setColor(Color.black);
g1.fillOval(x_click,y_move (j*5),5,5);
try
{
Thread.currentThread().sleep((v)/3);
} catch (InterruptedException e) {}
}
y_move = 400;
g1.setColor(Color.black);
while(y_movey_click)
{
g1.fillOval(x_click-2,y_move,9,5);
y_move -= 5;
}
v = 15;
for(int i=0;i=25;i)
{
r = (((int)Math.round(Math.random()*4321)) 0) 55;
g = (((int)Math.round(Math.random()*4321)) 0) 55;
b = (((int)Math.round(Math.random()*4321)) 0) 55;
g1.setColor(new Color(r,g,b));
g1.drawOval(x_click-3*i,y_click-3*i,6*i,6*i);
if(i23)
{
g1.drawOval(x_click-3*(i 1),y_click-3*(i 1),6*(i 1),6*(i 1));
g1.drawOval(x_click-3*(i 2),y_click-3*(i 2),6*(i 2),6*(i 2));
}
try
{
Thread.currentThread().sleep(v);
} catch (InterruptedException e) {}
g1.setColor(Color.black);
g1.drawOval(x_click-3*i,y_click-3*i,6*i,6*i);
}
}
/**
*对鼠标事件进行监听 。
*临听其鼠标按下事件 。
*当按下鼠标时，产生一个新线程 。
*/
public void mousePressed(MouseEvent e)
{
x = e.getX();
y = e.getY();
Thread one;
one = new Thread(this);
one.start();
one = null;
}
/**
*实现MouseListener接中的方法 。为一个空方法 。
*/
public void mouseReleased(MouseEvent e)
{
}
/**
*实现MouseListener接中的方法 。为一个空方法 。
*/
public void mouseEntered(MouseEvent e)
{
}
/**
*实现MouseListener接中的方法 。为一个空方法 。
*/
public void mouseExited(MouseEvent e)
{
}
/**
*实现MouseListener接中的方法 。为一个空方法 。
*/
public void mouseClicked(MouseEvent e)
{
}
}
求一个JAVA游戏代码?。。〖保 。。?/h2>俄罗斯方块——java源代码提供
import java.awt.*;
import java.awt.event.*;
//俄罗斯方块类
public class ERS_Block extends Frame{
public static boolean isPlay=false;
public static int level=1,score=0;
public static TextField scoreField,levelField;
public static MyTimer timer;
GameCanvas gameScr;
public static void main(String[] argus){
ERS_Block ers = new ERS_Block("俄罗斯方块游戏 V1.0 Author:Vincent");
WindowListener win_listener = new WinListener();
ers.addWindowListener(win_listener);
}
//俄罗斯方块类的构造方法
ERS_Block(String title){
super(title);
setSize(600,480);
setLayout(new GridLayout(1,2));
gameScr = new GameCanvas();
gameScr.addKeyListener(gameScr);
timer = new MyTimer(gameScr);
timer.setDaemon(true);
timer.start();
timer.suspend();
add(gameScr);
Panel rightScr = new Panel();
rightScr.setLayout(new GridLayout(2,1,0,30));
rightScr.setSize(120,500);
add(rightScr);
//右边信息窗体的布局
MyPanel infoScr = new MyPanel();
infoScr.setLayout(new GridLayout(4,1,0,5));
infoScr.setSize(120,300);
rightScr.add(infoScr);
//定义标签和初始值
Label scorep = new Label("分数:",Label.LEFT);
Label levelp = new Label("级数:",Label.LEFT);
scoreField = new TextField(8);
levelField = new TextField(8);
scoreField.setEditable(false);
levelField.setEditable(false);
infoScr.add(scorep);
infoScr.add(scoreField);
infoScr.add(levelp);
infoScr.add(levelField);
scorep.setSize(new Dimension(20,60));
scoreField.setSize(new Dimension(20,60));
levelp.setSize(new Dimension(20,60));
levelField.setSize(new Dimension(20,60));
scoreField.setText("0");
levelField.setText("1");
//右边控制按钮窗体的布局
MyPanel controlScr = new MyPanel();
controlScr.setLayout(new GridLayout(5,1,0,5));
rightScr.add(controlScr);
//定义按钮play
Button play_b = new Button("开始游戏");
play_b.setSize(new Dimension(50,200));
play_b.addActionListener(new Command(Command.button_play,gameScr));
//定义按钮Level UP
Button level_up_b = new Button("提高级数");
level_up_b.setSize(new Dimension(50,200));
level_up_b.addActionListener(new Command(Command.button_levelup,gameScr));
//定义按钮Level Down
Button level_down_b =new Button("降低级数");
level_down_b.setSize(new Dimension(50,200));
level_down_b.addActionListener(new Command(Command.button_leveldown,gameScr));
//定义按钮Level Pause
Button pause_b =new Button("游戏暂停");
pause_b.setSize(new Dimension(50,200));
pause_b.addActionListener(new Command(Command.button_pause,gameScr));
//定义按钮Quit
Button quit_b = new Button("退出游戏");
quit_b.setSize(new Dimension(50,200));
quit_b.addActionListener(new Command(Command.button_quit,gameScr));
controlScr.add(play_b);
controlScr.add(level_up_b);
controlScr.add(level_down_b);
controlScr.add(pause_b);
controlScr.add(quit_b);
setVisible(true);
gameScr.requestFocus();
}
}
//重写MyPanel类，使Panel的四周留空间
class MyPanel extends Panel{
public Insets getInsets(){
return new Insets(30,50,30,50);
}
}
//游戏画布类
class GameCanvas extends Canvas implements KeyListener{
final int unitSize = 30; //小方块边长
int rowNum; //正方格的行数
int columnNum; //正方格的列数
int maxAllowRowNum; //允许有多少行未削
int blockInitRow; //新出现块的起始行坐标
int blockInitCol; //新出现块的起始列坐标
int [][] scrArr; //屏幕数组
Block b; //对方快的引用
//画布类的构造方法
GameCanvas(){
rowNum = 15;
columnNum = 10;
maxAllowRowNum = rowNum - 2;
b = new Block(this);
blockInitRow = rowNum - 1;
blockInitCol = columnNum/2 - 2;
scrArr = new int [32][32];
}
//初始化屏幕，并将屏幕数组清零的方法
void initScr(){
for(int i=0;irowNum;i)
for (int j=0; jcolumnNum;j)
scrArr[j]=0;
b.reset();
repaint();
}
//重新刷新画布方法
public void paint(Graphics g){
for(int i = 0; irowNum; i)
for(int j = 0; jcolumnNum; j)
drawUnit(i,j,scrArr[j]);
}
//画方块的方法
public void drawUnit(int row,int col,int type){
scrArr[row][col] = type;
Graphics g = getGraphics();
tch(type){ //表示画方快的方法
case 0: g.setColor(Color.black);break; //以背景为颜色画
case 1: g.setColor(Color.blue);break; //画正在下落的方块
case 2: g.setColor(Color.magenta);break; //画已经落下的方法
}
g.fill3DRect(col*unitSize,getSize().height-(row 1)*unitSize,unitSize,unitSize,true);
g.dispose();
}
public Block getBlock(){
return b; //返回block实例的引用
}
//返回屏幕数组中(row,col)位置的属性值
public int getScrArrXY(int row,int col){
if (row0 || row = rowNum || col0 || col = columnNum)
return(-1);
else
return(scrArr[row][col]);
}
//返回新块的初始行坐标方法
public int getInitRow(){
return(blockInitRow); //返回新块的初始行坐标
}
//返回新块的初始列坐标方法
public int getInitCol(){
return(blockInitCol); //返回新块的初始列坐标
}
//满行删除方法
void deleteFullLine(){
int full_line_num = 0;
int k = 0;
for (int i=0;irowNum;i){
boolean isfull = true;
L1:for(int j=0;jcolumnNum;j)
if(scrArr[j] == 0){
k;
isfull = false;
break L1;
}
if(isfull) full_line_num;
if(k!=0k-1!=i!isfull)
for(int j = 0; jcolumnNum; j){
if (scrArr[j] == 0)
drawUnit(k-1,j,0);
else
drawUnit(k-1,j,2);
scrArr[k-1][j] = scrArr[j];
}
}
for(int i = k-1 ;irowNum; i){
for(int j = 0; jcolumnNum; j){
drawUnit(i,j,0);
scrArr[j]=0;
}
}
ERS_Block.score= full_line_num;
ERS_Block.scoreField.setText("" ERS_Block.score);
}
//判断游戏是否结束方法
boolean isGameEnd(){
for (int col = 0 ; col columnNum; col){
if(scrArr[maxAllowRowNum][col] !=0)
return true;
}
return false;
}
public void keyTyped(KeyEvent e){
}
public void keyReleased(KeyEvent e){
}
//处理键盘输入的方法
public void keyPressed(KeyEvent e){
if(!ERS_Block.isPlay)
return;
tch(e.getKeyCode()){
case KeyEvent.VK_DOWN:b.fallDown();break;
case KeyEvent.VK_LEFT:b.leftMove();break;
case KeyEvent.VK_RIGHT:b.rightMove();break;
case KeyEvent.VK_SPACE:b.leftTurn();break;
}
}
}
//处理控制类
class Command implements ActionListener{
static final int button_play = 1; //给按钮分配编号
static final int button_levelup = 2;
static final int button_leveldown = 3;
static final int button_quit = 4;
static final int button_pause = 5;
static boolean pause_resume = true;
int curButton; //当前按钮
GameCanvas scr;
//控制按钮类的构造方法
Command(int button,GameCanvas scr){
curButton = button;
this.scr=scr;
}
//按钮执行方法
public void actionPerformed (ActionEvent e){
tch(curButton){
case button_play:if(!ERS_Block.isPlay){
scr.initScr();
ERS_Block.isPlay = true;
ERS_Block.score = 0;
ERS_Block.scoreField.setText("0");
ERS_Block.timer.resume();
}
scr.requestFocus();
break;
case button_levelup:if(ERS_Block.level10){
ERS_Block.level;
ERS_Block.levelField.setText("" ERS_Block.level);
ERS_Block.score = 0;
ERS_Block.scoreField.setText("" ERS_Block.score);
}
scr.requestFocus();
break;
case button_leveldown:if(ERS_Block.level1){
ERS_Block.level--;
ERS_Block.levelField.setText("" ERS_Block.level);
ERS_Block.score = 0;
ERS_Block.scoreField.setText("" ERS_Block.score);
}
scr.requestFocus();
break;
case button_pause:if(pause_resume){
ERS_Block.timer.suspend();
pause_resume = false;
}else{
ERS_Block.timer.resume();
pause_resume = true;
}
scr.requestFocus();
break;
case button_quit:System.exit(0);
}
}
}
//方块类
class Block {
static int[][] pattern = {
{0x0f00,0x4444,0x0f00,0x4444},//用十六进至表示，本行表示长条四种状态
{0x04e0,0x0464,0x00e4,0x04c4},
{0x4620,0x6c00,0x4620,0x6c00},
{0x2640,0xc600,0x2640,0xc600},
{0x6220,0x1700,0x2230,0x0740},
{0x6440,0x0e20,0x44c0,0x8e00},
{0x0660,0x0660,0x0660,0x0660}
};
int blockType; //块的模式号（0-6）
int turnState; //块的翻转状态（0-3）
int blockState; //快的下落状态
int row,col; //块在画布上的坐标
GameCanvas scr;
//块类的构造方法
Block(GameCanvas scr){
this.scr = scr;
blockType = (int)(Math.random() * 1000)%7;
turnState = (int)(Math.random() * 1000)%4;
blockState = 1;
row = scr.getInitRow();
col = scr.getInitCol();
}
//重新初始化块 ， 并显示新块
public void reset(){
blockType = (int)(Math.random() * 1000)%7;
turnState = (int)(Math.random() * 1000)%4;
blockState = 1;
row = scr.getInitRow();
col = scr.getInitCol();
dispBlock(1);
}
//实现“块”翻转的方法
public void leftTurn(){
if(assertValid(blockType,(turnState1)%4,row,col)){
dispBlock(0);
turnState = (turnState1)%4;
dispBlock(1);
}
}
//实现“块”的左移的方法
public void leftMove(){
if(assertValid(blockType,turnState,row,col-1)){
dispBlock(0);
col--;
dispBlock(1);
}
}
//实现块的右移
public void rightMove(){
if(assertValid(blockType,turnState,row,col 1)){
dispBlock(0);
col;
dispBlock(1);
}
}
//实现块落下的操作的方法
public boolean fallDown(){
if(blockState == 2)
return(false);
if(assertValid(blockType,turnState,row-1,col)){
dispBlock(0);
row--;
dispBlock(1);
return(true);
}else{
blockState = 2;
dispBlock(2);
return(false);
}
}
//判断是否正确的方法
boolean assertValid(int t,int s,int row,int col){
int k = 0x8000;
for(int i = 0; i4; i){
for(int j = 0; j4; j){
if((int)(pattern[t][s]k) != 0){
int temp = scr.getScrArrXY(row-i,col j);
if (temp0||temp==2)
return false;
}
k = k1;
}
}
return true;
}
//同步显示的方法
public synchronized void dispBlock(int s){
int k = 0x8000;
for (int i = 0; i4; i){
for(int j = 0; j4; j){
if(((int)pattern[blockType][turnState]k) != 0){
scr.drawUnit(row-i,col j,s);
}
k=k1;
}
}
}
}
//定时线程
class MyTimer extends Thread{
GameCanvas scr;
public MyTimer(GameCanvas scr){
this.scr = scr;
}
public void run(){
while(true){
try{
sleep((10-ERS_Block.level1)*100);
}
catch(InterruptedException e){}
if(!scr.getBlock().fallDown()){
scr.deleteFullLine();
if(scr.isGameEnd()){
ERS_Block.isPlay = false;
suspend();
}else
scr.getBlock().reset();
}
}
}
class WinListener extends WindowAdapter{
public void windowClosing (WindowEvent l){
System.exit(0);
}
}
几个Java小游戏代码package reduce;
import java.applet.Applet;
import java.applet.AudioClip;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Toolkit;
import javax.sound.sampled.AudioFileFormat;
import javax.sound.sampled.AudioSystem;
import javax.swing.JFrame;
import javax.swing.JPanel;
import java.awt.Rectangle;
import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JOptionPane;
import javax.swing.JSlider;
import javax.swing.JLabel;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.io.File;
import java.util.Vector;
public class Frame extends JFrame implements Runnable {
JPanel contentPane;
JPanel jPanel1 = new JPanel();
JButton jButton1 = new JButton();
JSlider jSlider1 = new JSlider();
JLabel jLabel1 = new JLabel();
JButton jButton2 = new JButton();
JLabel jLabel2 = new JLabel();
int count = 1, rapidity = 80; // count 当前进行的个数, rapidity 游标的位置
int zhengque = 0, cuowu = 0;
int rush[] = { 10 ,20 ,30 };//游戏每关的个数 可以自由添加.列 { 10 ,20 ,30 ,40,50}
int rush_count = 0;//记录关数
char list[] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L',
'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y',
'Z', '1', '2', '3', '4', '5', '6', '7', '8', '9' };//随机出现的数字 可以自由添加
Vector number = new Vector();
String paiduan = "true";
AudioClip Musci_anjian, Music_shibai, Music_chenggong;
public Frame() {
try {
setDefaultCloseOperation(EXIT_ON_CLOSE);
//-----------------声音文件---------------------
Musci_anjian = Applet.newAudioClip(new File("sounds//anjian.wav")
.toURL());
Music_shibai = Applet.newAudioClip(new File("sounds//shibai.wav")
.toURL());
Music_chenggong = Applet.newAudioClip(new File(
"sounds//chenggong.wav").toURL());
//---------------------------------------
jbInit();
} catch (Exception exception) {
exception.printStackTrace();
}
}
/**
* Component initialization.
*
* @throws java.lang.Exception
*/
private void jbInit() throws Exception {
contentPane = (JPanel) getContentPane();
contentPane.setLayout(null);
setSize(new Dimension(588, 530));
setTitle("Frame Title");
jPanel1.setBorder(BorderFactory.createEtchedBorder());
jPanel1.setBounds(new Rectangle(4, 4, 573, 419));
jPanel1.setLayout(null);
jButton1.setBounds(new Rectangle(277, 442, 89, 31));
jButton1.setText("开始");
jButton1.addActionListener(new Frame1_jButton1_actionAdapter(this));
jSlider1.setBounds(new Rectangle(83, 448, 164, 21));
jSlider1.setMaximum(100);
jSlider1.setMinimum(1);
jSlider1.setValue(50);
jLabel1.setText("速度");
jLabel1.setBounds(new Rectangle(35, 451, 39, 18));
jButton2.setBounds(new Rectangle(408, 442, 89, 31));
jButton2.setText("结束");
jButton2.addActionListener(new Frame1_jButton2_actionAdapter(this));
jLabel2.setText("第一关:100个");
jLabel2.setBounds(new Rectangle(414, 473, 171, 21));
contentPane.add(jPanel1);
contentPane.add(jButton2);
contentPane.add(jButton1);
contentPane.add(jSlider1);
contentPane.add(jLabel1);
contentPane.add(jLabel2);
this.addKeyListener(new MyListener());
jButton1.addKeyListener(new MyListener());
jSlider1.addKeyListener(new MyListener());
jSlider1.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent e) {
rapidity = jSlider1.getValue();
}
});
}
public void run() {
number.clear();
zhengque = 0;
cuowu = 0;
paiduan = "true";
while (count = rush[rush_count]) {
try {
Thread t = new Thread(new Tthread());
t.start();
count= 1;
Thread.sleep(1000(int) (Math.random() * 2000)); // 生产下组停顿时间
// 最快1快.最慢2秒
} catch (InterruptedException e) {
e.printStackTrace();
}
}
while (true) { // 等待最后一个字符消失
if (number.size() == 0) {
break;
}
}
if (zhengque == 0) { // 为了以后相除..如果全部正确或者错误就会出现错误. 所以..
zhengque = 1;
}
if (cuowu == 0) {
cuowu = 1;
}
if (paiduan.equals("true")) { // 判断是否是自然结束
if (zhengque / cuowu = 2) {
JOptionPane.showMessageDialog(null, "恭喜打鸭子游戏的java代码你过关了");
rush_count= 1; // 自动加1关
if (rush_countrush.length) {
if (rapidity10) { // 当速度大于10的时候在-5提加速度.怕速度太快
rapidity -= 5; // 速度自动减10毫秒
jSlider1.setValue(rapidity); // 选择位置
}
Thread t = new Thread(this);
t.start();
} else {
JOptionPane.showMessageDialog(null, "牛B...你通关了..");
rush_count = 0;
count = 0;
}
} else {
JOptionPane.showMessageDialog(null, "请再接再励");
rush_count = 0;
count = 0;
}
} else {
rush_count = 0;
count = 0;
}
}
public void jButton1_actionPerformed(ActionEvent e) {
Thread t = new Thread(this);
t.start();
}
public void jButton2_actionPerformed(ActionEvent e) {
count = rush[rush_count]1;
paiduan = "flase";
}
class Tthread implements Runnable {
public void run() {
boolean fo = true;
int Y = 0, X = 0;
JLabel show = new JLabel();
show.setFont(new java.awt.Font("宋体", Font.PLAIN, 33));
jPanel1.add(show);
X = 10(int) (Math.random() * 400);
String parameter = list[(int) (Math.random() * list.length)]"";
Bean bean = new Bean();
bean.setParameter(parameter);
bean.setShow(show);
number.add(bean);
show.setText(parameter);
while (fo) {
// ---------------------数字下移--------------------
show.setBounds(new Rectangle(X, Y= 2, 33, 33));
try {
Thread.sleep(rapidity);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (Y = 419) {
fo = false;
for (int i = number.size() - 1; i = 0; i--) {
Bean bn = ((Bean) number.get(i));
if (parameter.equalsIgnoreCase(bn.getParameter())) {
cuowu= 1;
jLabel2.setText("正确:"zhengque"个,错误:"cuowu
"个");
number.removeElementAt(i);
Music_shibai.play();
break;
}
}
}
}
}
}
class MyListener extends KeyAdapter {
public void keyPressed(KeyEvent e) {
String uu = e.getKeyChar()"";
for (int i = 0; inumber.size(); i) {
Bean bean = ((Bean) number.get(i));
if (uu.equalsIgnoreCase(bean.getParameter())) {
zhengque= 1;
number.removeElementAt(i);
bean.getShow().setVisible(false);
jLabel2.setText("正确:"zhengque"个,错误:"cuowu"个");
Music_chenggong.play();
break;
}
}
Musci_anjian.play();
}
}
public static void main(String[] args) {
try {
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
} catch (Exception exception) {
exception.printStackTrace();
}
Frame frame = new Frame();
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
Dimension frameSize = frame.getSize();
if (frameSize.heightscreenSize.height) {
frameSize.height = screenSize.height;
}
if (frameSize.widthscreenSize.width) {
frameSize.width = screenSize.width;
}
frame.setLocation((screenSize.width - frameSize.width) / 2,
(screenSize.height - frameSize.height) / 2);
frame.setVisible(true);
}
}
class Frame1_jButton2_actionAdapter implements ActionListener {
private Frame adaptee;
Frame1_jButton2_actionAdapter(Frame adaptee) {
this.adaptee = adaptee;
}
public void actionPerformed(ActionEvent e) {
adaptee.jButton2_actionPerformed(e);
}
}
class Frame1_jButton1_actionAdapter implements ActionListener {
private Frame adaptee;
Frame1_jButton1_actionAdapter(Frame adaptee) {
this.adaptee = adaptee;
}
public void actionPerformed(ActionEvent e) {
adaptee.jButton1_actionPerformed(e);
}
}
class Bean {
String parameter = null;
JLabel show = null;
public JLabel getShow() {
return show;
}
public void setShow(JLabel show) {
this.show = show;
}
public String getParameter() {
return parameter;
}
public void setParameter(String parameter) {
this.parameter = parameter;
}
}
打鸭子游戏的java代码我只有一个打字母小游戏
软件设计模式鸭子模拟器假设打鸭子游戏的java代码我们需要设计出各种各样的鸭子打鸭子游戏的java代码，一边游泳戏水，一边呱呱叫 。很明显这时我们需要设计打鸭子游戏的java代码了一个鸭子超类（Superclass），并让各种鸭子继承此超类 。
public abstract class Duck {
public void Swim() {
//会游泳
}
public abstract display();//各种外观不一样，所以为抽象
public void Quack() {
//会叫
}
}
每一只鸭子就继承Duck类
public class MallardDuck extends Duck {
public void display() {
// 外观是绿色的
}
}
public class RedheadDuck extends Duck{
public void display(){
// 外观是红色的
}
}
好了，我们完成这些后 ， 但是发现我们需要有一些鸭子是会飞的，应该怎么修改呢？
也许你要说这很简单，在Duck类里面直接加入一个fly()方法 ， 不就可以了 。
public abstract class Duck {
public void Swim() {
//会游泳
}
public abstract display();//各种外观不一样，所以为抽象
public void Quack() {
//会叫
}
public void fly(){
//会飞
}
}
这时你会发现所有的鸭子都变成了会飞的,很明显这是不对了，例如橡皮鸭显然就不是了 。
你也许想到了另一种方法 ， 在会飞的鸭子类里才添加该方法不就可以了嘛，
public class MallardDuck extend Duck{
public void display(){
// 外观是绿色的
}
public void fly(){
//会飞
}
}
这个方法看起来是很不错，可是有很多种鸭子都会飞的时候，代码的复用性很明显是不够好的,你不得不在
每一个会飞的鸭子类里去写上同一个fly()方法,这可不是个好主意.
可能你又想到另一个方法：采用继承和覆盖 ， 在Duck类里实现fly()方法，在子类里如果不会飞的就覆盖它
public abstract class Duck {
public void Swim() {
//会游泳
}
public abstract display();//各种外观不一样，所以为抽象
public void Quack(){
//会叫
}
public void fly(){
//会飞
}
}
//橡皮鸭吱吱叫，不会飞
public class RubberDuck extend Duck{
public void quack(){
//覆盖成吱吱叫
}
public void display{
//外观是橡皮鸭
}
public void fly{
//什么也不做
}
}
这样我们真实现了确实能飞的鸭子才可以飞起来了，看起来主意不错！问题到这儿似乎得到了解决
但我们现在有了一种新的鸭子，诱铒鸭(不会飞也不会叫),看来需要这样来写
public class DecoyDuck extend Duck{
public void quack(){
//覆盖，变成什么也不做
【打鸭子游戏的java代码 打鸭子游戏的java代码怎么写】}
public void display(){
//诱饵鸭
}
public void fly(){
//覆盖，变成什么也不做
}
}
每当有新的鸭子子类出现或者鸭子新的特性出现，就不得不被迫在Duck类里添加并在所有子类里检查可能需要覆盖fly()和quark()...这简直是无穷尽的恶梦 。所以，我们需要一个更清晰的方法，让某些（而不是全部）鸭子类型可飞或可叫 。让鸭子的特性能有更好的扩展性 。
用一下接口的方式把fly()取出来，放进一个Flyable接口中，这样只有会飞的鸭子才实现这个接口，当然我们也可以照此来设计一个Quackbable接口，因为不是所有的鸭子都会叫,也只让会叫的鸭子才去实现这个接口.
但这个方法和上面提到的在子类里去实现fly一样笨，如果几十种都可以飞，你得在几十个鸭子里去写上一样的fly(),如果一旦这个fly有所变更，你将不得不找到这几十个鸭子去一个一个改它们的fly()方法 。
因为改变鸭子的行为会影响所有种类的鸭子，而这并不恰当 。Flyable与Quackable接口一开始似乎还挺不错，解决了问题（ 只有会飞的鸭子才继承Flyable） ，但是Java的接口不具有实现代码，所以继承接口无法达到代码的复用 。这意味着：无论何时你需要修改某个行为 ， 你必须得往下追踪并修改每一个定义此行为的类 。
策略模式的第一原则：找出应用中可能需要变化之处 ， 把它们独立出来 ， 不要和那些不需要变化的代码混在一起 。好吧，回头看一下这个Duck类，就我们目前所知，除了fly()和quack()的问题之外，Duck类还算一切正常，主要是鸭子的行为总是可能变化的，让我们头痛就在于这些行为的变化，那我们就把这些行为独立出来 。
为了要把这两个行为从Duck 类中分开，我们将把它们自Duck 类中取出，建立一组新类代表每个行为 。我们建立两组类（完全远离Duck类），一个是「fly」相关的，一个是「quack」相关的，每一组类将实现各自 的动作 。比方说，我们可能有一个类实现「呱呱叫」，另一个类实现「吱吱叫」 ， 另一个类实现「安静」 。我们利用接口代表每组行为 ， 比方说 ， FlyBehavior来代表飞的行为，QuackBehavior代表叫的行为，而让每一种行为具体类来实现该行为接口 。
在此，我们有两个接口，FlyBehavior和QuackBehavior，还有它们对应的类，负责实现具体的行为：
public interface FlyBehavior {
public void fly();
}
public class FlyWithWings implements FlyBehavior{
public void fly{}{
//实现鸭子飞行
}
}
public class FlyNoWay implements FlyBehavior{
public void fly{}{
//什么也不做，不会飞
}
}
public interface QuackBehavior{
public void quack();
}
public class Quack implements QuackBehavior{
public void quack(){
//实现鸭子呱呱叫
}
}
public class Squeak implements QuackBehavior{
public void quack(){
//实现鸭子吱吱叫
}
}
public class MuteQuack implements QuackBehavior{
public void quack(){
//什么也不做 ， 不会叫
}
}
实际上这样的设计，我们已经可以让飞行和呱呱叫的动作被其打鸭子游戏的java代码他的对象复用，因为这些行为已经与鸭子类无关了 。如果我们新增一些行为，也不会影响到既有的行为类 ， 也不会影响有已经使用到飞行行为的鸭子类 。
好了，我们设计好鸭子的易于变化的行为部分后，该到了整合鸭子行为的时候了 。
这时我们该想到策略模式的另一个原则了：
针对接口编程，而不是针对实现编程 。
首先，在鸭子中加入两个实例变量 ， 分别为「flyBehavior」与「quackBehavior」，声明为接口类型（ 而不是具体类实现类型），每个变量会利用多态的方式在运行时引用正确的行为类型（ 例如：FlyWithWings 、Squeak...等） 。我们也必须将Duck类与其所有子类中的fly()与quack()移除，因为这些行为已经被搬移到FlyBehavior与 Quackehavior类中了 ， 用performFly()和performQuack()取代Duck类中的fly()与quack() 。
public abstract class Duck(){
FlyBehavior flyBehavior;
QuackBehavior quackBehavior;
public void swim(){
//会游泳
}
public abstract void display();//各种外观不一样，所以为抽象
public void performQuack(){
quackBehavior.quack();
}
public void performFly(){
flyBehavior.fly();
}
}
很容易，是吧？想进行呱呱叫的动作，Duck对象只要叫quackBehavior对象
去呱呱叫就可以了 。在这部分的代码中，我们不在乎QuackBehavior 接口的对象到底是什么 ， 我们只关心该对象
知道如何进行呱呱叫就够了 。
好吧！ 现在来关心如何设定flyBehavior 与quackBehavior的实例变量 。
看看MallardDuck类：
public class MallardDuck extends Duck {
public MallardDuck() {
\\绿头鸭使用Quack类处理呱呱叫，所以当performQuack() 被调用，就把责任委托给Quack对象进行真正的呱呱叫 。
quackBehavior = new Quack();
\\使用FlyWithWings作为其FlyBehavior类型 。
flyBehavior = new FlyWithWings();
}
}
所以 ， 绿头鸭会真的『呱呱叫』，而不是『吱吱叫』，或『叫不出声』 。这是怎么办到的？当MallardDuck实例化时，它的构造器会
把继承来的quackBehavior实例变量初始化成Quack类型的新实例（Quack是QuackBehavior的具体实现类） 。同样的处理方式也可以用在飞行行为上： MallardDuck 的构造器将flyBehavior 实例变量初始化成FlyWithWings 类型的实例（
FlyWithWings是FlyBehavior的具体实现类） 。
输入下面的Duck类（Duck.java） 以及MallardDuck 类MallardDuck.java），并编译之 。
public abstract class Duck {
//为行为接口类型声明两个引用变量，所有鸭子子类（在同一个packge）都继承它们 。
FlyBehavior flyBehavior;
QuackBehavior quackBehavior;
public Duck() {
}
public abstract void display();
public void performFly() {
flyBehavior.fly();//委托给行为类
}
public void performQuack() {
quackBehavior.quack();//委托给行为类
}
public void swim() {
System.out.println("All ducksfloat, even decoys!");
}
}
public class MallardDuck extends Duck {
public MallardDuck() {
quackBehavior = newQuack();
flyBehavior = newFlyWithWings();
}
public void display() {
System.out.println("I’m a real Mallard duck");
}
}
输入FlyBehavior接口（FlyBehavior.java）与两个行为实现类（FlyWithWings.java与FlyNoWay.java），并编译之 。
public interface FlyBehavior {//所有飞行行为类必须实现的接口
public void fly();
}
public class FlyWithWings implements FlyBehavior {//这是飞行行为的实现，给「真会」飞的鸭子用 .. .
public void fly() {
System.out.println("I’m flying!!");
}
}
public class FlyNoWay implements FlyBehavior {//这是飞行行为的实现， 给「不会」飞的鸭子用（ 包括橡皮鸭和诱饵鸭）
public void fly() {
System.out.println("I can’t fly");
}
}
输入QuackBehavior接口（QuackBehavior.java)及其三个实现类（Quack.java、MuteQuack.java、Squeak.java），并编译之 。
public interface QuackBehavior {
public void quack();
}
public class Quack implements QuackBehavior {
public void quack() {
System.out.println(“Quack”);
}
}
public class MuteQuack implements QuackBehavior {
public void quack() {
System.out.println(“ Silence ”);
}
}
public class Squeak implements QuackBehavior {
public void quack() {
System.out.println(“Squeak”);
}
}
输入并编译测试类（MiniDuckSimulator.java）
public class MiniDuckSimulator {
public static void main(String[] args) {
Duck mallard = new MallardDuck();
mallard.display();
//这会调用MallardDuck继承来的performQuack()，进而委托给该对象的QuackBehavior对象处理 。（也就是说，调用继承来的quackBehavior的quack()）
mallard.performQuack();
//至于performFly() ，也是一样的道理 。
mallard.performFly();
}
}
运行结果：
I’m a real Mallard duck
Quack
I’m flying!!
虽然我们把行为设定成具体的类（通过实例化类似Quack 或FlyWithWings的行为类，并指定到行为引
用变量中），但是还是可以在运行时轻易地改变该行为 。
所以，目前的作法还是很有弹性的，只是初始化实例变量的作法不够弹性罢了 。
我们希望一切能有弹性，毕竟，正是因为一开始的设计的鸭子行为没有弹性，才让我们走到现在这条路 。
我们还想能够「指定」行为到鸭子的实例 ， 比方说， 想要产生绿头鸭实例，并指定特定「类型」的飞行
行为给它 。干脆顺便让鸭子的行为可以动态地改变好了 。换句话说，我们应该在鸭子类中包含设定行为的方法 。
因为quackBehavior实例变量是一个接口类型 ， 所以我们是能够在运行时，透过多态动态地指定不同的QuickBehavior实现类给它 。
我们在鸭子子类透过设定方法（settermethod）设定鸭子的行为 ， 而不是在鸭子的构造器内实例化 。
在Duck类中，加入两个新方法：从此以后，我们可以「随时」调用这两个方法改变鸭子的行为 。
public strate class Duck(){
FlyBehavior flyBehavior;
QuackBehavior quackBehavior;
public void setFlyBehavior(FlyBehavior fb) {
flyBehavior = fb;
}
public void setQuackBehavior(QuackBehavior qb) {
quackBehavior = qb;
}
}
好了，让我们再制造一个新的鸭子类型：模型鸭（ModelDuck.java）
public class ModelDuck extends Duck {
public ModelDuck() {
flyBehavior = new FlyNoWay();//初始状态，我们的模型鸭是不会飞的 。
quackBehavior = new Quack();//初始状态，我们的模型鸭是可以叫的.
}
public void display() {
System.out.println("I’m a modelduck");
}
}
建立一个新的FlyBehavior类型（FlyRocketPowered.java）
public class FlyRocketPowered implements FlyBehavior {
// 我们建立一个利用火箭动力的飞行行为 。
public void fly() {
System.out.println("I’m flying with arocket!");
}
}
改变测试类（MiniDuckSimulator.java），加上模型鸭，并使模型鸭具有火箭动力 。
public class MiniDuckSimulator {
public static void main(String[] args) {
Duck mallard = new MallardDuck();
mallard.performQuack();
mallard.performFly();
Duck model = new ModelDuck();
//第一次调用performFly() 会被委托给flyBehavior对象（也就是FlyNoWay对象），该对象是在模型鸭构造器中设置的 。
model.performFly();
//这会调用继承来的setter 方法，把火箭动力飞行的行为设定到模型鸭中 。哇咧！ 模型鸭突然具有火箭动力飞行能力 。
model.setFlyBehavior(new FlyRocketPowered());
//如果成功了 ， 就意味着模型鸭动态地改变行为 。如果把行为的实现绑死在鸭子类中 ， 可就无法做到这样 。
model.performFly();
}
}
运行一下，看下结果
I’m a real Mallard duck
Quack
I’m flying!!
I’m a model duck
I can’t fly
I’m flying with a rocket!
如同本例一般，当你将两个类结合起来使用，这就是组合（composition） 。这种作法和『继承』不同的地方在于，
鸭子的行为不是继承而来，而是和适当的行为对象『组合』而来 。
这是一个很重要的技巧 。其实是使用了策略模式中的第三个设计原则，多用组合，少用继承 。
现在来总结一下，鸭子的行为被放在分开的类中，此类专门提供某行为的实现 。
这样，鸭子类就不再需要知道行为的实现细节 。
鸭子类不会负责实现Flyable与Quackable接口，反而是由其他类专门实现FlyBehavior与QuackBehavior ，
这就称为「行为」类 。由行为类实现行为接口 ， 而不是由Duck类实现行为接口 。
这样的作法迥异于以往，行为不再是由继承Duck超类的具体实现而来 ， 或是继承某个接口并由子类自行实现而来 。
(这两种作法都是依赖于「实现」 ， 我们被实现绑得死死的 ， 没办法更改行为,除非写更多代码) 。
在我们的新设计中，鸭子的子类使用接口（ FlyBehavior与QuackBehavior）所表示的行为，所以实际的实现不会被
绑死在鸭子的子类中 。（ 换句话说，特定的实现代码位于实现FlyBehavior与QuakcBehavior的特定类中）,这样我们就获得了更大的灵活性和可扩展性 。
求一个简单又有趣的JAVA小游戏代码具体如下：
连连看的小源码
package Lianliankan;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class lianliankan implements ActionListener
{
JFrame mainFrame; //主面板
Container thisContainer;
JPanel centerPanel,southPanel,northPanel; //子面板
JButton diamondsButton[][] = new JButton[6][5];//游戏按钮数组
JButton exitButton,resetButton,newlyButton; //退出，重列 ， 重新开始按钮
JLabel fractionLable=new JLabel("0"); //分数标签
JButton firstButton,secondButton; //
分别记录两次62616964757a686964616fe59b9ee7ad9431333335326239被选中的按钮
int grid[][] = new int[8][7];//储存游戏按钮位置
static boolean pressInformation=false; //判断是否有按钮被选中
int x0=0,y0=0,x=0,y=0,fristMsg=0,secondMsg=0,validateLV; //游戏按钮的位置坐标
int i,j,k,n;//消除方法控制
代码（code）是程序员用开发工具所支持的语言写出来的源文件，是一组由字符、符号或信号码元以离散形式表示信息的明确的规则体系 。
对于字符和Unicode数据的位模式的定义 ， 此模式代表特定字母、数字或符号（例如 0x20 代表一个空格 ， 而 0x74 代表字符“t”） 。一些数据类型每个字符使用一个字节；每个字节可以具有 256 个不同的位模式中的一个模式 。
在计算机中，字符由不同的位模式（ON 或 OFF）表示 。每个字节有 8 位 ， 这 8 位可以有 256 种不同的 ON 和 OFF 组合模式 。对于使用 1 个字节存储每个字符的程序，通过给每个位模式指派字符可表示最多 256 个不同的字符 。2 个字节有 16 位，这 16 位可以有 65,536 种唯一的 ON 和 OFF 组合模式 。使用 2 个字节表示每个字符的程序可表示最多 65,536 个字符 。
单字节代码页是字符定义，这些字符映射到每个字节可能有的 256 种位模式中的每一种 。代码页定义大小写字符、数字、符号以及 !、@、#、% 等特殊字符的位模式 。每种欧洲语言（如德语和西班牙语）都有各自的单字节代码页 。
虽然用于表示 A 到 Z 拉丁字母表字符的位模式在所有的代码页中都相同，但用于表示重音字符（如"é"和"á"）的位模式在不同的代码页中却不同 。如果在运行不同代码页的计算机间交换数据，必须将所有字符数据由发送计算机的代码页转换为接收计算机的代码页 。如果源数据中的扩展字符在接收计算机的代码页中未定义，那么数据将丢失 。
如果某个数据库为来自许多不同国家的客户端提供服务，则很难为该数据库选择这样一种代码页，使其包括所有客户端计算机所需的全部扩展字符 。而且，在代码页间不停地转换需要花费大量的处理时间 。
求java小游戏源代码表1. CheckerDrag.java
// CheckerDrag.javaimport java.awt.*;import java.awt.event.*;public class CheckerDrag extends java.applet.Applet{// Dimension of checkerboard square.// 棋盘上每个小方格的尺寸final static int SQUAREDIM = 40;// Dimension of checkerboard -- includes black outline.// 棋盘的尺寸 – 包括黑色的轮廓线final static int BOARDDIM = 8 * SQUAREDIM2;// Dimension of checker -- 3/4 the dimension of a square.// 棋子的尺寸 – 方格尺寸的3/4final static int CHECKERDIM = 3 * SQUAREDIM / 4;// Square colors are dark green or white.// 方格的颜色为深绿色或者白色final static Color darkGreen = new Color (0, 128, 0);// Dragging flag -- set to true when user presses mouse button over checker// and cleared to false when user releases mouse button.// 拖动标记 --当用户在棋子上按下鼠标按键时设为true，// 释放鼠标按键时设为falseboolean inDrag = false;// Left coordinate of checkerboard's upper-left corner.// 棋盘左上角的左方向坐标int boardx;// Top coordinate of checkerboard's upper-left corner.//棋盘左上角的上方向坐标int boardy;// Left coordinate of checker rectangle origin (upper-left corner).// 棋子矩形原点(左上角)的左方向坐标int ox;// Top coordinate of checker rectangle origin (upper-left corner).// 棋子矩形原点(左上角)的上方向坐标int oy;// Left displacement between mouse coordinates at time of press and checker// rectangle origin.// 在按键时的鼠标坐标与棋子矩形原点之间的左方向位移int relx;// Top displacement between mouse coordinates at time of press and checker// rectangle origin.// 在按键时的鼠标坐标与棋子矩形原点之间的上方向位移int rely;// Width of applet drawing area.// applet绘图区域的宽度int width;// Height of applet drawing area.// applet绘图区域的高度int height;// Image buffer.// 图像缓冲Image imBuffer;// Graphics context associated with image buffer.// 图像缓冲相关联的图形背景Graphics imG;public void init (){// Obtain the size of the applet's drawing area.// 获取applet绘图区域的尺寸width = getSize ().width;height = getSize ().height;// Create image buffer.// 创建图像缓冲imBuffer = createImage (width, height);// Retrieve graphics context associated with image buffer.// 取出图像缓冲相关联的图形背景imG = imBuffer.getGraphics ();// Initialize checkerboard's origin, so that board is centered.// 初始化棋盘的原点 ， 使棋盘在屏幕上居中boardx = (width - BOARDDIM) / 21;boardy = (height - BOARDDIM) / 21;// Initialize checker's rectangle's starting origin so that checker is// centered in the square located in the top row and second column from// the left.// 初始化棋子矩形的起始原点，使得棋子在第一行左数第二列的方格里居中ox = boardxSQUAREDIM(SQUAREDIM - CHECKERDIM) / 21;oy = boardy(SQUAREDIM - CHECKERDIM) / 21;// Attach a mouse listener to the applet. That listener listens for// mouse-button press and mouse-button release events.// 向applet添加一个用来监听鼠标按键的按下和释放事件的鼠标监听器addMouseListener (new MouseAdapter (){public void mousePressed (MouseEvent e){// Obtain mouse coordinates at time of press.// 获取按键时的鼠标坐标int x = e.getX ();int y = e.getY ();// If mouse is over draggable checker at time// of press (i.e., contains (x, y) returns// true), save distance between current mouse// coordinates and draggable checker origin// (which will always be positive) and set drag// flag to true (to indicate drag in progress).// 在按键时如果鼠标位于可拖动的棋子上方// （也就是contains (x, y)返回true） ， 则保存当前// 鼠标坐标与棋子的原点之间的距离（始终为正值）并且// 将拖动标志设为true（用来表明正处在拖动过程中）if (contains (x, y)){relx = x - ox;rely = y - oy;inDrag = true;}}boolean contains (int x, int y){// Calculate center of draggable checker.// 计算棋子的中心位置int cox = oxCHECKERDIM / 2;int coy = oyCHECKERDIM / 2;// Return true if (x, y) locates with bounds// of draggable checker. CHECKERDIM / 2 is the// radius.// 如果(x, y)仍处于棋子范围内则返回true// CHECKERDIM / 2为半径return (cox - x) * (cox - x)(coy - y) * (coy - y)CHECKERDIM / 2 * CHECKERDIM / 2;}public void mouseReleased (MouseEvent e){// When mouse is released, clear inDrag (to// indicate no drag in progress) if inDrag is// already set.// 当鼠标按键被释放时，如果inDrag已经为true ， // 则将其置为false（用来表明不在拖动过程中）if (inDrag)inDrag = false;}});// Attach a mouse motion listener to the applet. That listener listens// for mouse drag events.//向applet添加一个用来监听鼠标拖动事件的鼠标运动监听器addMouseMotionListener (new MouseMotionAdapter (){public void mouseDragged (MouseEvent e){if (inDrag){// Calculate draggable checker's new// origin (the upper-left corner of// the checker rectangle).// 计算棋子新的原点（棋子矩形的左上角）int tmpox = e.getX () - relx;int tmpoy = e.getY () - rely;// If the checker is not being moved// (at least partly) off board,// assign the previously calculated// origin (tmpox, tmpoy) as the// permanent origin (ox, oy), and// redraw the display area (with the// draggable checker at the new// coordinates).// 如果棋子（至少是棋子的一部分）没有被// 移出棋盘 ， 则将之前计算的原点// (tmpox, tmpoy)赋值给永久性的原点(ox, oy)，// 并且刷新显示区域（此时的棋子已经位于新坐标上）if (tmpoxboardxtmpoyboardytmpoxCHECKERDIMboardxBOARDDIMtmpoyCHECKERDIMboardyBOARDDIM){ox = tmpox;oy = tmpoy;repaint ();}}}});}public void paint (Graphics g){// Paint the checkerboard over which the checker will be dragged.// 在棋子将要被拖动的位置上绘制棋盘paintCheckerBoard (imG, boardx, boardy);// Paint the checker that will be dragged.// 绘制即将被拖动的棋子paintChecker (imG, ox, oy);// Draw contents of image buffer.// 绘制图像缓冲的内容g.drawImage (imBuffer, 0, 0, this);}void paintChecker (Graphics g, int x, int y){// Set checker shadow color.// 设置棋子阴影的颜色g.setColor (Color.black);// Paint checker shadow.// 绘制棋子的阴影g.fillOval (x, y, CHECKERDIM, CHECKERDIM);// Set checker color.// 设置棋子颜色g.setColor (Color.red);// Paint checker.// 绘制棋子g.fillOval (x, y, CHECKERDIM - CHECKERDIM / 13, CHECKERDIM - CHECKERDIM / 13);}void paintCheckerBoard (Graphics g, int x, int y){// Paint checkerboard outline.// 绘制棋盘轮廓线g.setColor (Color.black);g.drawRect (x, y, 8 * SQUAREDIM1, 8 * SQUAREDIM1);// Paint checkerboard.// 绘制棋盘for (int row = 0; row8; row){g.setColor (((row1) != 0) ? darkGreen : Color.white);for (int col = 0; col8; col){g.fillRect (x1col * SQUAREDIM, y1row * SQUAREDIM,SQUAREDIM, SQUAREDIM);g.setColor ((g.getColor () == darkGreen) ? Color.white :darkGreen);}}}// The AWT invokes the update() method in response to the repaint() method// calls that are made as a checker is dragged. The default implementation// of this method, which is inherited from the Container class, clears the// applet's drawing area to the background color prior to calling paint().// This clearing followed by drawing causes flicker. CheckerDrag overrides// update() to prevent the background from being cleared, which eliminates// the flicker.// AWT调用了update()方法来响应拖动棋子时所调用的repaint()方法 。该方法从// Container类继承的默认实现会在调用paint()之前，将applet的绘图区域清除// 为背景色，这种绘制之后的清除就导致了闪烁 。CheckerDrag重写了update()来// 防止背景被清除 ， 从而消除了闪烁 。public void update (Graphics g){paint (g);}}
打鸭子游戏的java代码的介绍就聊到这里吧，感谢你花时间阅读本站内容 ， 更多关于打鸭子游戏的java代码怎么写、打鸭子游戏的java代码的信息别忘了在本站进行查找喔 。

    推荐阅读


    上一篇：如何在广告服务器中实现用户登录？ ad服务器怎么用户登录

    下一篇：支持鸿蒙上滑卡片的软件，鸿蒙上滑卡片有什么用