锐客网

  1. 首页 > 生活百科 > it技术 > >

java武器类代码 java工具类代码

IT技术public

java当中怪物类如何引用武器类打怪兽类这是个挺有趣的问题，我们可以一起来分析下：
1.这里面只有两个类 ， 武器类和怪兽类；而动作只有一个，打 。
2.面向对象的思想是为类分配职责 ， 那么打这个动作到底分配给谁？
很明显应该分配给怪兽类，因为打这个动作涉及的大部分数据都是怪兽类包含的，从常识上来讲分配给武器类感觉怪怪的...
3.从上面可以想象到会出现这样的情况monster.hit(otherMonster)，这里monster是打 ， otherMonster是被打 。hit方法里面需要将otherMonster的信息获取出来，然后计算打的过程...这样会把otherMonster的数据封装破坏掉，如果扩展otherMonster，显然你必需要在hit方法里判断otherMonster是哪种类型 。但是monster.hit(otherMonster)又是符合对象的思维的 。那么问题出在哪里？
问题出在打是一个动词，打这个方法分配给了一个对象，但作用的是另一个对象，因此而破坏了数据封装 。如果打分配给一个对象，同时作用的是这个对象，那么问题就解决了 。
怎样把打分配给一个对象，同时作用的是这个对象呢？答案是把打转换成被打 ， 于是就成了otherMonster.hit()，在monster需要去打otherMonster时 ， 调用otherMonster.hit()就可以了 。
4.武器类还没有被引入进来 ， 明显武器不会自动攻击，他必须装备在monster上，我们可以把weapon作为monster的成员 。
5.武器类可以被使用在打这个动作上 ， 于是我们为hit方法增加武器参数，于是就变成otherMonster.hit(weapon) ， 这个方法是在monster内部调用的，weapon也是monster的成员，没有破坏封装性 。
6.至此 ， 你提的这个问题就是这样了...
class Monster{
private Weapon weapon;
public void hit(Weapon weapon){
//dosometing.
}
public Weapon getWeapon(){
return weapon;
}
public void setWeapon(Weapon weapon){
this.weapon = weapon;
}
}
是不是感觉怪怪的...我们可以继续来探讨这个问题：
为什么感觉怪怪的？是因为这个问题太简化了，简化到我们并不知道Monster被打之后到底发生什么 。
感觉这个很像个游戏，大部分游戏都是基于hitpoint(血量)的，为了使这个问题带感一些，我们给Monster一个int类型的hitPoint 。
同时给武器类赋予一个attackPoint ， 在Monster被打的时候扣除attackPoint数量的hitPoint 。
那么问题来了，hit方法里需要获取Weapon中的attackPoint，这又会把Weapon的数据封装破坏掉...
为此我们需要给Monster一个直接扣除hitPoint的方法damage(int attackPoint)，让Weapon能够调用damage方法把自身的attackPoint传递进来 。
Weapon本身我们可以分配一个attack(Monster monster)方法来给Monster把自身传递进来，于是程序就变成了：
class Monster{
private Weapon weapon;
private int hitPoint;
public void hit(Weapon weapon){
weapon.attack(this);
}
public void damage(int attackPoint){
this.hitPoint -= attackPoint;
}
public Weapon getWeapon(){
return weapon;
}
public void setWeapon(Weapon weapon){
this.weapon = weapon;
}
}
class Weapon{
private int attackPoint;
public void attack(Monster monster){
monster.damage(attackPoint);
}
}
也许有人会问，hit里面调用weapon.attack，attack里面又调用monster.damage ， 那还不如在hit里直接获取weapon的attackPoint ， 然后直接扣除hitPoint 。
为什么要这么麻烦呢?实际上这里Weapon是一个策略(Strategy模式)，由策略来决定对对象到底采取什么样的作用 。这里感觉麻烦也是因为问题太简单了 。
再带感一点，我们参考网游的做法，Monster本身有一定的躲避和格挡率，同时某些Weapon可能会有暴击率：
此时我们需要在hit方法里先计算是否躲避或者格挡，如果都不成功，才调用weapon.attack(this).在attack方法里，需要先计算是否暴击，如果暴击，则把attackPoint乘以2 。于是又变成了
class Monster{
private Weapon weapon;
private int hitPoint;
private int dodge;//100%比例
private int block;//100%比例
public void hit(Weapon weapon){
if (isDodge()){
return;
}
if (isBlock){
return;
}
weapon.attack(this);
}
public void damage(int attackPoint){
this.hitPoint -= attackPoint;
}
public boolean isDodge(){
//COMPUTE IS DODGE?
}
public boolean isBlock(){
//COMPUTE IS BLOCK?
}
public Weapon getWeapon(){
return weapon;
}
public void setWeapon(Weapon weapon){
this.weapon = weapon;
}
}
class Weapon{
private int attackPoint;
private int critical;//100%比例
public void attack(Monster monster){
int actualAttackPoint = isCritical()?attackPoint*2:attackPoint;
monster.damage(actualAttackPoint);
}
public boolean isCritical(){
//COMPUTE IS CRITICAL
}
}
【java武器类代码 java工具类代码】这样就不觉得麻烦了...
最后应该把monster抽象成接口，因为可能不只是monster可以被武器打哦
你还可以后面再加入怎么判断Monster挂了，通过观察者模式来通知打人者，还有其他各种各样带感的东西 。
祝你好运！
请帮我用JAVA写出来import java.util.LinkedHashSet;
import java.util.Set;
/**
* 角色类
*/
public class Role {
private SetArmor armors = new LinkedHashSetArmor();
/**
* 编号
*/
private String id;
/**
* 名字
*/
private String name;
/**
* 队伍
*/
private String group;
/**
* 血量
*/
private int hp;
/**
* 力量
*/
private int power;
/**
* 防卸
*/
private int prevent;
/**
* 攻击
*
* @param role 攻击对象
*/
public void attack(Role role){
while(this.hp0role.hp0){
System.out.println(String.format("%1$s对%2$s发起攻击", this.name, role.name));
role.hp -= (this.power - role.prevent);
System.out.println(String.format("%1$s受到攻击力：%2$d，防卸：%3$d ， 剩余血量：%4$d", role.name, this.power, role.prevent, role.hp));
if(role.hp = 0){
System.out.println(String.format("%1$s已经阵亡！", role.name));
for(Armor a : role.armors){
System.out.println(String.format("盔甲：%1$s,防卸：%2$d", a.getName(), a.getPrevent()));
}
return;
}else{
if(role.hp30){
role.useArmor(new Armor("头盔", 2));
}
role.attack(this);
}
}
}
/**
* 使用盔甲
* @param armor 盔甲
*/
public void useArmor(Armor armor){
for(Armor a : armors){
if(armor.getName().equals(a.getName())){
return;
}
}
armors.add(armor);
System.out.println(String.format("%1$s使用了%2$s盔甲，增加了%3$d防卸！", this.name, armor.getName(), armor.getPrevent()));
this.prevent= armor.getPrevent();
}
public String getGroup() {
return group;
}
public void setGroup(String group) {
this.group = group;
}
public int getHp() {
return hp;
}
public void setHp(int hp) {
this.hp = hp;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getPower() {
return power;
}
public void setPower(int power) {
this.power = power;
}
public int getPrevent() {
return prevent;
}
public void setPrevent(int prevent) {
this.prevent = prevent;
}
public Role(){}
public Role(String name, int hp, int power, int prevent) {
super();
this.name = name;
this.hp = hp;
this.power = power;
this.prevent = prevent;
}
/**
* @param args
*/
public static void main(String[] args) {
Role r0 = new Role("张飞", 100, 15, 20);
Role r1 = new Role("吕布", 100, 35, 10);
r0.attack(r1);
}
}
/**
* 武器
*/
class Weapon {
/**
* 名称
*/
private String name;
/**
* 攻击
*/
private int attack;
public int getAttack() {
return attack;
}
public void setAttack(int attack) {
this.attack = attack;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
/**
* 盔甲
*/
class Armor {
/**
* 名称
*/
private String name;
/**
* 防卸力
*/
private int prevent;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getPrevent() {
return prevent;
}
public void setPrevent(int prevent) {
this.prevent = prevent;
}
public Armor(){}
public Armor(String name, int prevent) {
super();
this.name = name;
this.prevent = prevent;
}
}
假设一个游戏人物类继承了武器类，装备类 ， C中可以多继承 ， 如何用java中接口来解决上面的问题可以去看一下设计模式 java武器类代码，《HeadFirst》里边有说到java武器类代码你这个 。
首先java是不支持多继承的 。
设计模式原则之一java武器类代码，要针对接口编程java武器类代码，多用组合，少用继承 。
你可以写一个武器接口，比如WeaponBehavior ， 里边有useWeapon()函数 。
然后有各种各样的武器来分别实现这个接口 。
比如SwordBehavior,GunBehavior等 。
然后在游戏人物中有一个WeaponBehavior属性，当java武器类代码他是用剑时，就把他设置为SwordBehavior，用枪时就设置为GunBehavior 。
装备同理
高分求java代码 （认真回答还有悬赏）按java武器类代码你现在说的这个内容java武器类代码，我觉得三个类就能表现出来，我写java武器类代码了一下，你看看能不能满足你的要求：
/**
* 运动员信息
* @author songfeng163
*/
public class PlayerState {
private String lx; //运动类型
private String xing; // 姓
private String ming; // 名
public String getLx() {
return lx;
}
public void setLx(String lx) {
this.lx = lx;
}
public String getXing() {
return xing;
}
public void setXing(String xing) {
this.xing = xing;
}
public String getMing() {
return ming;
}
public void setMing(String ming) {
this.ming = ming;
}
//返回姓名信息
@Override
public String toString() {
return xing ming;
}
}
/**
* 运动员得分信息
* @author songfeng163
*/
public class SoccerPlayerStats {
private PlayerState player;//运动员信息
private double spointsScored;//点球得分
private double assists;//助攻得分
private double penaltyKickRate;//罚球得分概率
public PlayerState getPlayer() {
return player;
}
public void setPlayer(PlayerState player) {
this.player = player;
}
public double getSpointsScored() {
return spointsScored;
}
public void setSpointsScored(double spointsScored) {
this.spointsScored = spointsScored;
}
public double getAssists() {
return assists;
}
public void setAssists(double assists) {
this.assists = assists;
}
public double getPenaltyKickRate() {
return penaltyKickRate;
}
public void setPenaltyKickRate(double penaltyKickRate) {
this.penaltyKickRate = penaltyKickRate;
}
//返回分数信息
@Override
public String toString() {
return "** PLAYER ADDED **"player.toString() "; Points:"spointsScored"; Assists: "assists"; Penalty Kick %:"penaltyKickRate;
}
}
这里是主类：
import java.util.Scanner;
import java.util.List;
import java.util.ArrayList;
/**
* 主类
* @author songfeng163
*/
public class MyMain {
//添加方法
public ListSoccerPlayerStats add(ListSoccerPlayerStats list){
Scanner in=new Scanner(System.in);
PlayerState player=new PlayerState();
SoccerPlayerStats score=new SoccerPlayerStats();
System.out.println("请输入运动类型：足球，高尔夫，田径：");
player.setLx(in.next());
System.out.println("请输入姓：");
player.setXing(in.next());
System.out.println("请输入名：");
player.setMing(in.next());
System.out.println("请输入该运动员的点球得分：");
score.setSpointsScored(in.nextDouble());
System.out.println("请输入该运动员的助攻得分：");
score.setAssists(in.nextDouble());
System.out.println("请输入该运动员的罚球得分概率：");
score.setPenaltyKickRate(in.nextDouble());
score.setPlayer(player);
System.out.println(score);//显示新添加的人员
list.add(score);
return list;
}
//删除方法
public ListSoccerPlayerStats del(ListSoccerPlayerStats list){
Scanner in=new Scanner(System.in);
PlayerState player=new PlayerState();
System.out.println("请输入要删除运动员的姓：");
player.setXing(in.next());
System.out.println("请输入要删除运动员的名：");
player.setMing(in.next());
for(SoccerPlayerStats score:list){
if(score.getPlayer().getXing().equals(player.getXing())
score.getPlayer().getMing().equals(player.getMing())){
list.remove(score);
break;
}
}
return list;
}
//显示方法
public void show(ListSoccerPlayerStats list){
System.out.println("当前共有：" list.size() "条记录，内容如下：");
for(SoccerPlayerStats score:list){
System.out.println(score);
}
}
//保存方法
public ListSoccerPlayerStats save(ListSoccerPlayerStats list){
System.out.println("请输入要保存的文件名：");
Scanner in=new Scanner(System.in);
String fileName=in.next();
try{
BufferedWriter bw = new BufferedWriter(new FileWriter("C:/" fileName));
for(SoccerPlayerStats score:list){
bw.write(score.toString());
bw.newLine();
}
bw.flush();
bw.close();
}catch(Exception ex){
ex.printStackTrace();
}
System.out.println("** 1 RECORD SAVED TO " fileName " **");
return list;
}
public static void main(String[] args) {
MyMain myMain=new MyMain();
Scanner in=new Scanner(System.in);
//如果像你说的是数组的话，数据没有办法动态变化，所以我用java武器类代码了list
ListSoccerPlayerStats list=new ArrayListSoccerPlayerStats();
String cz="QUIT";//默认的操作为退出
System.out.println("下面如何操作（ADD, REMOVE, SHOW, SAVE, QUIT）java武器类代码？");
String czin=in.next();//输入数据
cz=czin.toUpperCase();//转换成大写
while(!cz.equals("QUIT")){//不是退出
if(cz.equals("ADD")){//添加数据
list = myMain.add(list);
}else if(cz.equals("REMOVE")){//删除数据
list = myMain.del(list);
}else if(cz.equals("SHOW")){//显示数据
myMain.show(list);
}else if(cz.equals("SAVE")){//保存数据
myMain.save(list);
}
System.out.println("下面如何操作（ADD, REMOVE, SHOW, SAVE, QUIT）？");
czin=in.next();//输入数据
cz=czin.toUpperCase();//转换成大写
}
System.out.println("** GOODBYE! **");
}
}
运行结果如下：
下面如何操作（ADD, REMOVE, SHOW, SAVE, QUIT）？
add
请输入运动类型：足球 ， 高尔夫，田径：
足球
请输入姓：
王
请输入名：
明
请输入该运动员的点球得分：
4
请输入该运动员的助攻得分：
2
请输入该运动员的罚球得分概率：
0.25
** PLAYER ADDED **王明; Points:4.0; Assists: 2.0; Penalty Kick %:0.25
下面如何操作（ADD, REMOVE, SHOW, SAVE, QUIT）？
add
请输入运动类型：足球，高尔夫 ， 田径：
高尔夫
请输入姓：
李
请输入名：
三
请输入该运动员的点球得分：
2
请输入该运动员的助攻得分：
2
请输入该运动员的罚球得分概率：
0.3
** PLAYER ADDED **李三; Points:2.0; Assists: 2.0; Penalty Kick %:0.3
下面如何操作（ADD, REMOVE, SHOW, SAVE, QUIT）？
show
当前共有：2条记录，内容如下：
** PLAYER ADDED **王明; Points:4.0; Assists: 2.0; Penalty Kick %:0.25
** PLAYER ADDED **李三; Points:2.0; Assists: 2.0; Penalty Kick %:0.3
下面如何操作（ADD, REMOVE, SHOW, SAVE, QUIT）？
save
请输入要保存的文件名：
Playerdata.txt
下面如何操作（ADD, REMOVE, SHOW, SAVE, QUIT）？
remove
请输入要删除运动员的姓：
李
请输入要删除运动员的名：
三
下面如何操作（ADD, REMOVE, SHOW, SAVE, QUIT）？
show
当前共有：1条记录 ， 内容如下：
** PLAYER ADDED **王明; Points:4.0; Assists: 2.0; Penalty Kick %:0.25
下面如何操作（ADD, REMOVE, SHOW, SAVE, QUIT）？
quit
** GOODBYE! **
扫雷java源代码import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class Frame
extends JFrame {
JTextField text;
JLabel nowBomb, setBomb;
int BombNum, BlockNum; // 当前雷数,当前方块数
int rightBomb, restBomb, restBlock; // 找到的地雷数，剩余雷数，剩余方块数
JButton start = new JButton(" 开始 ");
JPanel MenuPamel = new JPanel();
JPanel bombPanel = new JPanel();
Bomb[][] bombButton;
JPanel c;
BorderLayout borderLayout1 = new BorderLayout();
GridLayout gridLayout1 = new GridLayout();
public Frame() {
try {
setDefaultCloseOperation(EXIT_ON_CLOSE);
jbInit();
}
catch (Exception exception) {
exception.printStackTrace();
}
}
private void jbInit() throws Exception {
c = (JPanel) getContentPane();
setTitle("扫雷");
c.setBackground(Color.WHITE);
MenuPamel.setBackground(Color.GRAY);
c.setLayout(borderLayout1);
setSize(new Dimension(600, 600));
setResizable(false);
BlockNum = 144;
BombNum = 10;
text = new JTextField("10 ", 3);
nowBomb = new JLabel("当前雷数"":"BombNum);
setBomb = new JLabel("设置地雷数");
start.addActionListener(new Frame1_start_actionAdapter(this));
MenuPamel.add(setBomb);
MenuPamel.add(text);
MenuPamel.add(start);
MenuPamel.add(nowBomb);
c.add(MenuPamel, java.awt.BorderLayout.SOUTH);
bombPanel.setLayout(gridLayout1);
gridLayout1.setColumns( (int) Math.sqrt(BlockNum));
gridLayout1.setRows( (int) Math.sqrt(BlockNum));
bombButton = new Bomb[ (int) Math.sqrt(BlockNum)][ (int) Math.sqrt(BlockNum)];
for (int i = 0; i(int) Math.sqrt(BlockNum); i) {
for (int j = 0; j(int) Math.sqrt(BlockNum); j) {
bombButton[i][j] = new Bomb(i, j);
//bombButton[i][j].setSize(10, 10);
bombButton[i][j].setFont(new Font("", Font.PLAIN, 14));//设置字体大小
bombButton[i][j].setForeground(Color.white);
bombButton[i][j].addMouseListener(new Bomb_mouseAdapter(this));
bombButton[i][j].addActionListener(new Bomb_actionAdapter(this));
bombPanel.add(bombButton[i][j]);
}
}
c.add(bombPanel, java.awt.BorderLayout.CENTER);
startBomb();
}
/* 开始按钮 */
public void start_actionPerformed(ActionEvent e) {
int num=Integer.parseInt(text.getText().trim());
if (num = 5num50) {
BombNum = num;
startBomb();
}
else if (num5) {
JOptionPane.showMessageDialog(null, "您设置的地雷数太少了,请重设!", "错误",
JOptionPane.ERROR_MESSAGE);
num=10;
BombNum = num;
}
else {
JOptionPane.showMessageDialog(null, "您设置的地雷数太多了,请重设!", "错误",
JOptionPane.ERROR_MESSAGE);
num=10;
BombNum = num;
}
}
/* 开始,布雷 */
public void startBomb() {
nowBomb.setText("当前雷数""："BombNum);
for (int i = 0; i(int) Math.sqrt(BlockNum); i) {
for (int j = 0; j(int) Math.sqrt(BlockNum); j) {
bombButton[i][j].isBomb = false;
bombButton[i][j].isClicked = false;
bombButton[i][j].isRight = false;
bombButton[i][j].BombFlag = 0;
bombButton[i][j].BombRoundCount = 9;
bombButton[i][j].setEnabled(true);
bombButton[i][j].setText("");
bombButton[i][j].setFont(new Font("", Font.PLAIN, 14));//设置字体大小
bombButton[i][j].setForeground(Color.BLUE);
rightBomb = 0;
restBomb = BombNum;
restBlock = BlockNum - BombNum;
}
}
for (int i = 0; iBombNum; ) {
int x = (int) (Math.random() * (int) (Math.sqrt(BlockNum) - 1));
int y = (int) (Math.random() * (int) (Math.sqrt(BlockNum) - 1));
if (bombButton[x][y].isBomb != true) {
bombButton[x][y].isBomb = true;
i;
}
}
CountRoundBomb();
}
/* 计算方块周围雷数 */
public void CountRoundBomb() {
for (int i = 0; i(int) Math.sqrt(BlockNum); i) {
for (int j = 0; j(int) Math.sqrt(BlockNum); j) {
int count = 0;
// 当需要检测的单元格本身无地雷的情况下,统计周围的地雷个数
if (bombButton[i][j].isBomb != true) {
for (int x = i - 1; xi2; x) {
for (int y = j - 1; yj2; y) {
if ( (x = 0)(y = 0)
(x( (int) Math.sqrt(BlockNum)))
(y( (int) Math.sqrt(BlockNum)))) {
if (bombButton[x][y].isBomb == true) {
count;
}
}
}
}
bombButton[i][j].BombRoundCount = count;
}
}
}
}
/* 是否挖完了所有的雷 */
public void isWin() {
restBlock = BlockNum - BombNum;
for (int i = 0; i(int) Math.sqrt(BlockNum); i) {
for (int j = 0; j(int) Math.sqrt(BlockNum); j) {
if (bombButton[i][j].isClicked == true) {
restBlock--;
}
}
}
if (rightBomb == BombNum || restBlock == 0) {
JOptionPane.showMessageDialog(this, "您挖完了所有的雷，您胜利了!", "胜利",
JOptionPane.INFORMATION_MESSAGE);
startBomb();
}
}
/** 当选中的位置为空,则翻开周围的地图* */
public void isNull(Bomb ClickedButton) {
int i, j;
i = ClickedButton.num_x;
j = ClickedButton.num_y;
for (int x = i - 1; xi2; x) {
for (int y = j - 1; yj2; y) {
if ( ( (x != i) || (y != j))(x = 0)(y = 0)
(x( (int) Math.sqrt(BlockNum)))
(y( (int) Math.sqrt(BlockNum)))) {
if (bombButton[x][y].isBomb == false
bombButton[x][y].isClicked == false
bombButton[x][y].isRight == false) {
turn(bombButton[x][y]);
}
}
}
}
}
/* 翻开 */
public void turn(Bomb ClickedButton) {
ClickedButton.setEnabled(false);
ClickedButton.isClicked = true;
if (ClickedButton.BombRoundCount0) {
ClickedButton.setText(ClickedButton.BombRoundCount"");
}
else {
isNull(ClickedButton);
}
}
/* 左键点击 */
public void actionPerformed(ActionEvent e) {
if ( ( (Bomb) e.getSource()).isClicked == false
( (Bomb) e.getSource()).isRight == false) {
if ( ( (Bomb) e.getSource()).isBomb == false) {
turn( ( (Bomb) e.getSource()));
isWin();
}
else {
for (int i = 0; i(int) Math.sqrt(BlockNum); i) {
for (int j = 0; j(int) Math.sqrt(BlockNum); j) {
if (bombButton[i][j].isBomb == true) {
bombButton[i][j].setText("b");
}
}
}
( (Bomb) e.getSource()).setForeground(Color.RED);
( (Bomb) e.getSource()).setFont(new Font("", Font.BOLD, 20));
( (Bomb) e.getSource()).setText("X");
JOptionPane.showMessageDialog(this, "你踩到地雷了，按确定重来", "踩到地雷", 2);
startBomb();
}
}
}
/* 右键点击 */
public void mouseClicked(MouseEvent e) {
Bomb bombSource = (Bomb) e.getSource();
boolean right = SwingUtilities.isRightMouseButton(e);
if ( (right == true)(bombSource.isClicked == false)) {
bombSource.BombFlag = (bombSource.BombFlag1) % 3;
if (bombSource.BombFlag == 1) {
if (restBomb0) {
bombSource.setForeground(Color.RED);
bombSource.setText("F");
bombSource.isRight = true;
restBomb--;
}
else {
bombSource.BombFlag = 0;
}
}
else if (bombSource.BombFlag == 2) {
restBomb;
bombSource.setText("Q");
bombSource.isRight = false;
}
else {
bombSource.setText("");
}
if (bombSource.isBomb == true) {
if (bombSource.BombFlag == 1) {
rightBomb;
}
else if (bombSource.BombFlag == 2) {
rightBomb--;
}
}
nowBomb.setText("当前雷数"":"restBomb);
isWin();
}
}
public static void main(String[] args) {
Frame frame = new Frame();
frame.setVisible(true);
}
}
class Frame1_start_actionAdapter
implements ActionListener {
private Frame adaptee;
Frame1_start_actionAdapter(Frame adaptee) {
this.adaptee = adaptee;
}
public void actionPerformed(ActionEvent e) {
adaptee.start_actionPerformed(e);
}
}
////////////////////////////
class Bomb
extends JButton {
int num_x, num_y; // 第几号方块
int BombRoundCount; // 周围雷数
boolean isBomb; // 是否为雷
boolean isClicked; // 是否被点击
int BombFlag; // 探雷标记
boolean isRight; // 是否点击右键
public Bomb(int x, int y) {
num_x = x;
num_y = y;
BombFlag = 0;
BombRoundCount = 9;
isBomb = false;
isClicked = false;
isRight = false;
}
}
class Bomb_actionAdapter
implements ActionListener {
private Frame adaptee;
Bomb_actionAdapter(Frame adaptee) {
this.adaptee = adaptee;
}
public void actionPerformed(ActionEvent e) {
adaptee.actionPerformed(e);
}
}
class Bomb_mouseAdapter
extends MouseAdapter {
private Frame adaptee;
Bomb_mouseAdapter(Frame adaptee) {
this.adaptee = adaptee;
}
public void mouseClicked(MouseEvent e) {
adaptee.mouseClicked(e);
}
}
求一个简单的JAVA游戏代码，100行左右，谢谢！import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class Painter extends JFrame{
/**
*
*/
private static final long serialVersionUID = 8160427604782702376L;
CanvasPanel canvas = new CanvasPanel();;
public Painter() {
super("Star");
this.add(canvas);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.pack();
this.setResizable(false);
this.setLocationRelativeTo(null);
this.setVisible(true);
}
public static void main(String[] args) {
new Painter();
}
}
class CanvasPanel extends JPanel implements ActionListener{
/**
*
*/
private static final long serialVersionUID = -4642528854538741028L;
private JButton[] btn = new JButton[4];
private String[] btn_name = {" ", "-", "R", "L"};
private int center_x = 200, center_y = 200, radius = 100, degree = 0;
public CanvasPanel() {
this.setPreferredSize(new Dimension(400, 500));
this.setLayout(null);
for(int i = 0; i4; i) {
btn[i] = new JButton(btn_name[i]);
btn[i].setBounds(160i * 60, 425, 50, 50);
btn[i].addActionListener(this);
this.add(btn[i]);
}
}
@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);
for(int i = 0; i5; i) {
g.drawLine( (int) (center_xradius * Math.sin(Math.toRadians(degree72 * i))),
(int) (center_y - radius * Math.cos(Math.toRadians(degree72 * i))),
(int) (center_xradius * Math.sin(Math.toRadians(degree72 * i144))),
(int) (center_y - radius * Math.cos(Math.toRadians(degree72 * i144))));
}
}
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
if(e.getActionCommand() == " ") {
if(radius200)
radius= 2;
repaint();
} else if(e.getActionCommand() == "-") {
if(radius0)
radius -= 2;
repaint();
} else if(e.getActionCommand() == "R") {
degree = (degree2) % 360;
repaint();
} else if(e.getActionCommand() == "L") {
degree = (degree - 2) % 360;
repaint();
}
}
}
关于java武器类代码和java工具类代码的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站 。

    推荐阅读


    上一篇：微信为什么无法连接服务器？ 怎么微信未连接服务器

    下一篇：服务器主城建筑 服务器缺建筑师会怎么样