飞翔的小鸟

运行游戏如下：

 

碰到柱子就结束游戏

 App

GameApp类

1. package App;

3. import main.GameFrame;

5. public class GameApp {

6. public static void main(String[] args) {//游戏的入口

7. new GameFrame();

8. }

9. }

main

Barrier 类

1. package main;

3. import util.Constant;

4. import util.GameUtil;

6. import java.awt.*;

7. import java.awt.image.BufferedImage;

8. import java.util.Random;

10. /**

11. * 障碍物类

12. */

13. public class Barrier {

16. //矩形参数

17. private Rectangle rect;

19. private boolean mob = true;

21. //障碍物移动速度

22. private int speed = 3;

23. //障碍物需要的三个图片

24. private static BufferedImage[] img;

26. //障碍物的状态

27. private boolean visible;

30. static {

31. final int COUNT = 3;

32. //类加载的时候将三个图片初始化

33. img = new BufferedImage[COUNT];

34. for (int i = 0; i < COUNT; i++) {

35. img[i] = GameUtil.loadBufferedImage(Constant.BARRIER_IMG_PATH[i]);

36. }

37. }

39. //位置

40. private int x, y;

41. //宽度和高度

42. private int width, height;

43. //障碍物的类型

44. private int type;

45. public static final int TYPE_TOP_NORMAL = 0;

46. public static final int TYPE_BOTTOM_NORMAL = 2;

47. public static final int TYPE_HOVER_NORMAL = 4;

48. public static final int TYPE_MOBILE = 6;

50. //获得障碍物的宽度和高度

51. public static final int BARRIRE_WIDTH = img[0].getWidth();

52. public static final int BARRIRE_HEIGHT = img[0].getHeight();

53. public static final int BARRIRE_HEAD_WIDTH = img[1].getWidth();

54. public static final int BARRIRE_HEAD_HEIGHT = img[1].getHeight();

56. public Barrier() {

58. rect = new Rectangle();

60. }

62. public Barrier(int x, int y, int height, int type) {

63. this.x = x;

64. this.y = y;

65. this.height = height;

66. this.type = type;

67. this.width = BARRIRE_WIDTH;

68. }

70. //根据不同的类型绘制障碍物

71. public void draw(Graphics g) {

72. switch (type) {

73. case TYPE_TOP_NORMAL:

74. drawTopMormal(g);

75. break;

76. case TYPE_BOTTOM_NORMAL:

77. drawNomalTop(g);

78. break;

79. case TYPE_HOVER_NORMAL:

80. drawHoverNormal(g);

81. break;

82. case TYPE_MOBILE:

83. drawMobile(g);

84. break;

85. }

87. }

89. //绘制从上向下的障碍物

90. private void drawTopMormal(Graphics g) {

91. //求出所需要的障碍物的块数

92. int count = (height - BARRIRE_HEAD_HEIGHT) / BARRIRE_HEIGHT + 1;

93. //for循坏绘制障碍物

94. for (int i = 0; i < count; i++) {

95. g.drawImage(img[0], x, y + i * BARRIRE_HEIGHT, null);

96. }

98. //绘制头

99. int y = height - BARRIRE_HEAD_HEIGHT;

100. g.drawImage(img[2], x - (BARRIRE_HEAD_WIDTH - BARRIRE_WIDTH) / 2, y, null);

101. x -= speed;

102. if (x < 50) {

103. visible = false;

104. }

105. rect(g);

108. }

110. //绘制从下向上的障碍物

111. private void drawNomalTop(Graphics g) {

112. //求出所需要的障碍物的块数

113. int count = height / BARRIRE_HEIGHT + 1;

114. //for循环绘制障碍物

115. for (int i = 0; i < count; i++) {

116. g.drawImage(img[0], x, Constant.FRAM_HEIGNT - i * BARRIRE_HEIGHT, null);

117. }

118. //绘制头

119. int y = Constant.FRAM_HEIGNT - height;

120. g.drawImage(img[1], x - (BARRIRE_HEAD_WIDTH - BARRIRE_WIDTH) / 2, y, null);

121. x -= speed;

122. if (x < -50) {

123. visible = false;

124. }

125. rect(g);

126. }

127. //绘制中间的障碍物

128. private void drawHoverNormal(Graphics g) {

129. //求出所需要的障碍物的块数

130. int count = (height-BARRIRE_HEAD_HEIGHT)/BARRIRE_HEIGHT;

131. //绘制上头

132. g.drawImage(img[1],x,y,null);

133. //for循环绘制障碍物

134. for (int i = 0; i < count; i++) {

135. g.drawImage(img[0], x, y+BARRIRE_HEAD_HEIGHT+i*BARRIRE_HEIGHT, null);

136. }

137. rect(g);

139. //绘制下头

140. int y11 = y+height-BARRIRE_HEAD_HEIGHT;

141. g.drawImage(img[2],x,y11,null);

142. x -= speed;

143. if (x < -50) {

144. visible = false;

145. }

146. }

148. //绘制移动的障碍物

149. private void drawMobile(Graphics g) {

150. //求出所需要的障碍物的块数

151. int count = (height-BARRIRE_HEAD_HEIGHT)/BARRIRE_HEIGHT;

152. //绘制上头

153. g.drawImage(img[1],x,y,null);

154. //for循环绘制障碍物

155. for (int i = 0; i < count; i++) {

156. g.drawImage(img[0], x, y+BARRIRE_HEAD_HEIGHT+i*BARRIRE_HEIGHT, null);

157. }

158. rect(g);

160. //绘制下头

161. int y11 = y+height-BARRIRE_HEAD_HEIGHT;

162. g.drawImage(img[2],x,y11,null);

163. x -= speed;

164. if (x < -50) {

165. visible = false;

166. }

168. if (mob) {

169. y+=5;

170. if (y >= 250) {

171. mob=false;

172. }

173. }else if (!mob){

174. y-=5;

175. if (y <= 100) {

176. mob=true;

177. }

178. }

179. }

181. /**

182. * 绘制障碍物碰撞矩形

183. *

184. * @return

185. */

186. public void rect(Graphics g) {

187. int x1 = this.x;

188. int y1 = this.y;

189. int w1 = img[0].getWidth();

190. // g.setColor(Color.blue);

191. // g.drawRect(x1, y1, w1, height);

192. setRecyangle(x1, y1, w1, height);

193. }

195. /**

196. * 障碍物的碰撞矩形参数

197. *

198. * @return

199. */

200. public void setRecyangle(int x, int y, int width, int height) {

201. rect.x = x;

202. rect.y = y;

203. rect.width = width;

204. rect.height = height;

205. }

208. //判断什么时候绘制下一组障碍物

209. public boolean isInFrame() {

210. return 600 - x > 150;

211. }

213. public int getX() {

214. return x;

215. }

217. public void setX(int x) {

218. this.x = x;

219. }

221. public int getY() {

222. return y;

223. }

225. public void setY(int y) {

226. this.y = y;

227. }

229. public int getHeight() {

230. return height;

231. }

233. public void setHeight(int height) {

234. this.height = height;

235. }

237. public int getType() {

238. return type;

239. }

241. public void setType(int type) {

242. this.type = type;

243. }

245. public boolean isVisible() {

246. return visible;

247. }

249. public void setVisible(boolean visible) {

250. this.visible = visible;

251. }

253. public Rectangle getRect() {

254. return rect;

255. }

256. }

Barrierpool 类 

1. package main;

4. import java.util.ArrayList;

5. import java.util.List;

7. /**

8. * 为了避免反复的创建和销毁对象，使用对象池来提前创建好一些对象。

9. * 使用的时候从池中获得，使用完毕后，归还

10. */

11. public class Barrierpool {

12. //用于管理池中所有对象的容器

13. private static List pool = new ArrayList<>();

14. //池中初始的对象个数

15. public static final int initCount = 16;

16. //对象池中最大个数

17. public static final int maxCOunt = 20;

19. static {

20. //初始化池中的对象

21. for (int i = 0; i < initCount; i++) {

22. pool.add(new Barrier());

23. }

24. }

27. /**

28. * 从池中获取一个对象

29. */

30. public static Barrier getPool(){

31. int size = pool.size();

32. //如果池中有对象才可以拿

33. if (size > 0) {

34. //移除并返回对象

35. System.out.println("拿走一个");

36. return pool.remove(size-1);

37. }else {

38. //池中没有对象了 只能new

39. System.out.println("新的对象");

40. return new Barrier();

41. }

42. }

45. /**

46. * 将对象归还容器中

47. */

48. public static void setPool(Barrier barrier){

49. if (pool.size() < maxCOunt) {

50. pool.add(barrier);

51. System.out.println("容器归还了");

52. }

53. }

56. }

Bird 类

1. package main;

4. import static util.Constant.*;

5. import util.GameUtil;

6. import java.awt.*;

7. import java.awt.image.BufferedImage;

9. /**

10. * 小鸟类

11. */

12. public class Bird {

14. //小鸟矩形对象

15. private Rectangle rect;

17. //小鸟加速度

18. private int acceleration;

20. //小鸟的生命

21. public boolean life = true;

23. //存放小鸟图片

24. private BufferedImage[] images;

25. public static final int BIRD_IMG_COUNT = 3;

26. //鸟的状态

27. private int state;

28. public static final int STATE_NORMAR = 0;//平着飞

29. public static final int STATE_UP = 1;//向上飞

30. public static final int STATE_DOWN = 2;//向下飞

32. //小鸟的位置

33. private int x=200,y=200;

36. //小鸟移动方向 上下

37. private boolean up=false,down=false;

39. //小鸟移动速度

40. private int speed=4;

43. //构造方法中对资源初始化

44. public Bird() {

45. images = new BufferedImage[BIRD_IMG_COUNT];

46. for (int i = 0; i < BIRD_IMG_COUNT; i++) {

47. images[i] = GameUtil.loadBufferedImage(BIRD_IMG[i]);

48. }

50. int w = images[0].getWidth();

51. int h = images[0].getHeight();

52. rect = new Rectangle(w,h);

54. }

56. //绘制小鸟

57. public void draw(Graphics g) {

59. flyLogic();

61. g.drawImage(images [state], x, y, null);

63. //绘制小鸟的矩形

64. g.drawRect(x,y,(int)rect.getWidth(), rect.height);

65. rect.x=this.x;

66. rect.y=this.y;

67. }

71. //控制小鸟移动方向

72. public void flyLogic(){

73. if (up){

74. acceleration--;

75. y+=acceleration;

76. if (acceleration < -10) {

77. acceleration=-10;

78. }

79. if (y<20){

80. y=20;

81. acceleration=0;

82. }

83. }

84. if (!up){

85. acceleration++;

86. y+=acceleration;

87. if (acceleration > 10) {

88. acceleration=10;

89. }

90. if (y>475){

91. y=475;

92. acceleration=0;

93. }

94. }

96. }

101. public void fly(int fly){

102. switch (fly){

103. case 1:

104. state=1;

105. up=true;

106. break;

107. case 5:

108. state=2;

109. up=false;

110. break;

111. }

112. }

114. public Rectangle getRect() {

115. return rect;

116. }

118. /**

119. * 重新绘制小鸟的位置

120. */

121. public void restartDraw(){

122. life=true;

123. x=200;

124. y=200;

125. }

127. }

 Cloud 类

1. package main;

3. import java.awt.*;

4. import java.awt.image.BufferedImage;

6. /**

7. * 云彩类

8. */

9. public class Cloud {

10. //云彩图片

11. private BufferedImage img;

12. //云彩速度

13. private int speed;

14. //云彩的位置

15. private int x,y;

17. public Cloud(){}

19. public Cloud(BufferedImage img, int speed, int x, int y) {

20. this.img = img;

21. this.speed = speed;

22. this.x = x;

23. this.y = y;

24. }

26. public void draw(Graphics g){

27. x-=speed;

28. g.drawImage(img,x,y,null);

29. }

30. /**

31. * 用于判断云彩是否飞出屏幕以外

32. */

33. public boolean isOutFrame(){

34. if (x < -100) {

35. return true;

36. }

37. return false;

38. }

40. }

GameBackGround 类

1. package main;

3. import static util.Constant.*;

5. import util.Constant;

6. import util.GameUtil;

8. import java.awt.*;

9. import java.awt.image.BufferedImage;

11. /**

12. * 游戏背景类

13. */

14. public class GameBackGround {

15. //背景需要的资源图片

16. private BufferedImage bkimg;

18. //构造器初始化资源

19. public GameBackGround(){

20. bkimg = GameUtil.loadBufferedImage(Constant.BK_IMG_OATH);

21. }

23. //绘制图片

24. public void draw(Graphics g){

26. //填充背景色

27. g.setColor(BK_COLOR);

28. g.fillRect(0,0,FRAM_WIDTH,FRAM_HEIGNT);

29. g.setColor(Color.black);

32. //得到图片的高度和宽度

33. int height = bkimg.getHeight();

34. int weight = bkimg.getWidth();

35. //循环的次数

36. int count = Constant.FRAM_WIDTH/weight+1;

37. for (int i = 0; i < count; i++) {

38. g.drawImage(bkimg,weight*i,Constant.FRAM_HEIGNT-height,null);

39. }

40. }

41. }

GameBarrierLayer  类

1. package main;

4. import util.Constant;

6. import java.awt.*;

7. import java.io.*;

8. import java.util.ArrayList;

9. import java.util.List;

10. import java.util.Random;

13. /**

14. * 游戏中障碍物层

15. */

16. public class GameBarrierLayer {

18. private GameTime gameTime;

20. private int txt;

22. private Random random = new Random();

24. private List barriers;

26. public GameBarrierLayer() {

27. barriers = new ArrayList<>();

28. gameTime = new GameTime();

29. }

31. //绘制障碍物

32. public void draw(Graphics g, Bird bird) {

33. for (int i = 0; i < barriers.size(); i++) {

34. Barrier barrier = barriers.get(i);

36. if (barrier.isVisible()) {

37. barrier.draw(g);

38. } else {

39. Barrier remove = barriers.remove(i);

40. Barrierpool.setPool(remove);

41. i--;

42. }

43. }

44. collideBird(bird);

45. logic(g);

46. }

48. public void logic(Graphics g) {

49. if (barriers.size() == 0) {

50. ran();

51. gameTime.begin();

52. insert(600, 0, numberTop, 0);

53. insert(600, 500 - numberDown, numberDown, 2);

54. } else {

55. long differ = gameTime.differ();

56. g.setColor(Color.white);

57. g.setFont(new Font("微软雅黑", 1, 20));

58. g.drawString("坚持了：" + differ + "秒", 30, 50);

60. //显示最高成绩

61. txt = getTxt();

62. if (differ <= txt){

63. g.drawString("最高成绩:" + txt , 200, 50);

64. }else {

65. setTxt(String.valueOf(differ));

66. g.drawString("最高成绩:" + getTxt() , 200, 50);

67. }

69. //判断最后一个障碍物是否完全进入屏幕内

70. Barrier last = barriers.get(barriers.size() - 1);

71. if (last.isInFrame()) {

72. ran();

73. if (number < 50){

74. insert(600,32,440,4);

75. }else if (number>450){

76. insert(600,125,200,6);

77. }else {

78. insert(600, 0, numberTop, 0);

79. insert(600, 500 - numberDown, numberDown, 2);

80. }

82. }

83. }

84. }

86. //用于储存游戏数据

87. File file = new File("C:\\game.txt");

89. /**

90. * 从文件获取数据

91. * @return

92. */

93. public int getTxt() {

94. BufferedReader in = null;

95. try {

96. in = new BufferedReader(new FileReader(file));

97. } catch (FileNotFoundException e) {

98. e.printStackTrace();

99. }

100. int read = 0;

101. try {

102. read = Integer.parseInt(in.readLine());

103. } catch (IOException e) {

104. e.printStackTrace();

105. }

106. try {

107. in.close();

108. } catch (IOException e) {

109. e.printStackTrace();

110. }

111. return read;

112. }

114. /**

115. * 写入数据到文件

116. * @param str

117. */

118. public void setTxt(String str) {

119. FileWriter out = null;

120. try {

121. out = new FileWriter(file);

122. } catch (IOException e) {

123. e.printStackTrace();

124. }

125. try {

126. out.write(str);

127. } catch (IOException e) {

128. e.printStackTrace();

129. }

130. try {

131. out.close();

132. } catch (IOException e) {

133. e.printStackTrace();

134. }

135. }

138. /**

139. * 用于从池中获取对象，并吧参数封装成barrier 存入barriers数组中

140. */

141. public void insert(int x, int y, int num, int type) {

142. Barrier top = Barrierpool.getPool();

143. top.setX(x);

144. top.setY(y);

145. top.setHeight(num);

146. top.setType(type);

147. top.setVisible(true);

148. barriers.add(top);

149. }

152. //上方障碍物高度

153. private int numberTop;

154. //下方障碍物高度

155. private int numberDown;

156. private int number;

158. //产生两个100-500之间的随机高度

159. public void ran() {

160. numberTop = random.nextInt(400) + 100;

161. numberDown = random.nextInt(400) + 100;

162. number = random.nextInt(500);

163. //如果管道重合，则重新随机

164. if (numberTop + numberDown > 450) {

165. ran();

166. }

167. }

169. /**

170. * 判断障碍物和小鸟发生碰撞

171. */

172. public boolean collideBird(Bird bird) {

173. for (int i = 0; i < barriers.size(); i++) {

174. Barrier barrier = barriers.get(i);

175. //判断矩形是否相交

176. if (barrier.getRect().intersects(bird.getRect())) {

177. System.out.println("装上啦");

178. bird.life = false;

179. }

180. }

181. return false;

182. }

184. /**

185. * 用于清空障碍物的池子

186. */

187. public void restant(){

188. barriers.clear();

189. }

192. }

GameFrame 类

1. package main;

3. import static util.Constant.*;

5. import java.awt.*;

6. import java.awt.event.*;

7. import java.awt.image.BufferedImage;

9. /**

10. * 游戏的主窗口类，所有的关于游戏中绘制的内容都在此类中完成。

11. */

12. public class GameFrame extends Frame {

14. //实例化gamebackGround类

15. private GameBackGround gameBackGround;

17. //实例化Bird类

18. private Bird bird;

20. //实例化GameBarrierLayer类

21. private GameBarrierLayer gameBarrierLayer;

23. //实例化GameFrontGround类

24. private GameFrontGround gameFrontGround;

27. //存放图片的图片

28. private BufferedImage buffimg = new BufferedImage(FRAM_WIDTH,FRAM_HEIGNT,BufferedImage.TYPE_4BYTE_ABGR);

31. //构造方法中初始化一些参数

32. public GameFrame(){

33. //窗口是否可见

34. setVisible(true);

35. //窗口的大小

36. setSize(FRAM_WIDTH,FRAM_HEIGNT);

37. //窗口的标题

38. setTitle(FRAM_TITLE);

39. //窗口的初始化位置

40. setLocation(FRAM_X,FRAM_Y);

41. //窗口的大小不可改变

42. setResizable(false);

45. //窗口的关闭事件

46. addWindowListener(new WindowAdapter() {

47. @Override

48. public void windowClosing(WindowEvent e) {

49. System.exit(0);//结束程序

50. }

51. });

54. //初始化游戏对象

55. initGamg();

57. new run().start();

59. //添加按键监听

60. addKeyListener(new KeyAdapter() {

61. @Override

62. public void keyPressed(KeyEvent e) {

63. add(e);

64. }

66. @Override

67. public void keyReleased(KeyEvent e) {

68. minu(e);

69. }

70. });

74. }

76. //对游戏中的对象初始化

77. public void initGamg(){

78. gameBackGround = new GameBackGround();

79. bird = new Bird();

80. gameFrontGround = new GameFrontGround();

81. gameBarrierLayer = new GameBarrierLayer();

82. }

86. class run extends Thread{

87. @Override

88. public void run() {

89. while (true) {

90. repaint();

91. try {

92. Thread.sleep(33);

93. } catch (InterruptedException e) {

94. e.printStackTrace();

95. }

96. }

97. }

98. }

101. /**

102. * 所有的我们需要绘制的内容都在此方法中进行调用绘制

103. */

104. @Override

105. public void update(Graphics g) {

106. if(bird.life){

107. //得到图片的画笔

108. Graphics graphics = buffimg.getGraphics();

110. gameBackGround.draw(graphics);

111. bird.draw(graphics);

112. gameFrontGround.draw(graphics);

113. gameBarrierLayer.draw(graphics,bird);

115. //一次性的将图片绘制到屏幕中

116. g.drawImage(buffimg,0,0,null);

117. }else {

118. String over = "游戏结束";

119. g.setColor(Color.red);

120. g.setFont(new Font("微软雅黑",1,60));

121. g.drawString(over,180,250);

123. String reset = "Space Reset Game";

124. g.drawString(reset,25,350);

125. }

126. }

129. //按键

130. public void add(KeyEvent e){

131. switch (e.getKeyCode()){

132. case KeyEvent.VK_UP:

133. bird.fly(1);

134. break;

135. case KeyEvent.VK_SPACE:

136. if (bird.life == false) {

137. restart();

138. }

139. break;

140. }

141. }

145. //抬键

146. public void minu(KeyEvent e){

147. switch (e.getKeyCode()){

148. case KeyEvent.VK_UP:

149. bird.fly(5);

150. break;

151. }

152. }

154. /**

155. * 重置游戏

156. */

157. public void restart(){

158. gameBarrierLayer.restant();

159. bird.restartDraw();

160. }

163. }

GameFrontGround 类

1. package main;

3. import util.Constant;

4. import util.GameUtil;

6. import java.awt.*;

7. import java.awt.image.BufferedImage;

8. import java.util.ArrayList;

9. import java.util.List;

10. import java.util.Random;

12. /**

13. * 游戏的前景类

14. */

15. public class GameFrontGround {

16. //云彩的个数

17. private static final int CLOUND_COUNT = 2;

18. //存放云彩的容器

19. private List clouds;

20. //云彩的飞行速度

21. private static final int CLOUNG_SPEED = 1;

22. //使用到图片资源

23. private BufferedImage[] img;

25. //用于产生随机数

26. private Random random;

28. // 构造器初始化数据

29. public GameFrontGround() {

30. clouds = new ArrayList<>();

31. img = new BufferedImage[CLOUND_COUNT];

33. //容器中添加云彩的图片

34. for (int i = 0; i < CLOUND_COUNT; i++) {

35. img[i] = GameUtil.loadBufferedImage("img/cloud0" + i + ".png");

36. }

37. random = new Random();

38. }

40. //绘制云彩

41. public void draw(Graphics g) {

42. logic();

43. for (int i = 0; i < clouds.size(); i++) {

44. clouds.get(i).draw(g);

45. }

46. }

48. /**

49. * 用于云彩的个数控制

50. */

51. private void logic() {

52. if ((int) (500 * Math.random()) < 5) {

53. Cloud cloud = new Cloud(img[random.nextInt(CLOUND_COUNT)], CLOUNG_SPEED, 600, random.nextInt(150));

54. clouds.add(cloud);

55. }

56. for (int i = 0; i < clouds.size(); i++) {

57. Cloud cloud = clouds.get(i);

58. if (cloud.isOutFrame()){

59. clouds.remove(i);

60. i--;

61. System.out.println("移除了"+cloud);

62. }

63. }

65. }

66. }

GameTime 类

1. package main;

3. /**

4. * 游戏计时器

5. */

6. public class GameTime {

8. //开始

9. private long beginTime;

10. //结束

11. private long endTime;

12. //时间差

13. private long differ;

15. public GameTime(){}

17. public void begin(){

18. beginTime = System.currentTimeMillis();

19. }

20. public long differ(){

21. endTime = System.currentTimeMillis();

22. return differ=(endTime-beginTime)/1000;

23. }

25. }

untl

Constant 类

1. package util;

3. import java.awt.*;

5. /**

6. * @author

7. * @create

8. */

9. public class Constant {

10. //窗口的大小

11. public static final int FRAM_WIDTH= 600;

12. public static final int FRAM_HEIGNT= 500;

14. //窗口标题

15. public static final String FRAM_TITLE= "飞翔的小鸟";

17. //窗口的初始化位置

18. public static final int FRAM_X= 200;

19. public static final int FRAM_Y= 200;

21. //背景图片

22. public static final String BK_IMG_OATH = "img/bird_bk.png";

24. //背景色

25. public static final Color BK_COLOR = new Color(0x4BC4CF);

27. //小鸟图片资源

28. public static final String[] BIRD_IMG={

29. "img/bird_normal.png","img/bird_up.png","img/bird_down.png"

30. };

32. //障碍物图片资源

33. public static final String[] BARRIER_IMG_PATH ={

34. "img/barrier.png","img/barrier_up.png","img/barrier_down.png"};

35. }

GameUtil 类

1. package util;

3. import javax.imageio.ImageIO;

4. import java.awt.image.BufferedImage;

5. import java.io.FileInputStream;

6. import java.io.IOException;

8. /**

9. * 游戏工具类

10. */

11. public class GameUtil {

12. /**

13. *该方法传入一个图片路径 读取图片

14. */

15. public static BufferedImage loadBufferedImage(String ImgPath){

16. try {

17. return ImageIO.read(new FileInputStream(ImgPath));

18. } catch (IOException e) {

19. e.printStackTrace();

20. }

21. return null;

22. }

23. }