基于Java的超级玛丽游戏的设计与实现(含源文件)
欢迎添加微信互相交流学习哦！
项目源码：https://gitee.com/oklongmm/biye
基于java的超级玛丽游戏的设计与实现
摘要
近年来，Java作为一种新的编程语言，以其简单性、可移植性和平台无关性等优点，得到了广泛地应用。J2SE称为Java标准版或Java标准平台。J2SE提供了标准的SDK开发平台。利用该平台可以开发Java桌面应用程序和低端的服务器应用程序，也可以开发Java Applet程序。
“超级玛丽”游戏是一个经典的游戏，它因操作简单、娱乐性强而广受欢迎。本游戏中通过总结和分析JAVA游戏的开发流程和代码功能的设计，采用面向对象的设计模式，对游戏中的所有物体赋予对象的概念和属性。开发了一款超级玛丽游戏，该游戏主要分为窗体类、场景类、马里奥类、敌人类、障碍物类等几个类。在主程序运行的线程中，用户控制的超级玛丽随方向键的操作而移动，并且可以实现马里奥游戏中的一些基本功能，例如踩死敌人或者顶掉砖块。本游戏采用双缓存技术，解决了游戏过程中的闪屏问题。通过本游戏的开发，达到学习Java技术和熟悉软件开发流程的目的。
本文在介绍Java相关技术和国内外发展现状的基础上，对“超级玛丽”游戏的整个生命周期的各个开发阶段进行了详细地介绍。为了保证程序代码的正确性和功能实现的可靠性，本文还介绍了游戏软件的程序调试过程和功能测试结果。
【关键字】：面向对象；Java；碰撞检测；超级玛丽
Design and implementation of java-based Super Mario game
Abstract
In recent years, Java as a new programming language, with its simplicity, portability and platform independence, etc., have been widely used. J2SE called Java Standard Edition or Java standard platforms. J2SE SDK provides a standard development platform. You can use the platform to develop Java desktop applications and low-end server applications, you can develop Java Applet program.
"Super Mario" game is a classic game, because it is simple, entertaining and popular. The game features through the development process and code design summary and analysis of JAVA games, using object-oriented design patterns, all objects of the game gives the concept of objects and attributes. Developed a Super Mario game, the game is divided into several classes form class, class scene, Mario class, class enemies, obstacles and so on. In the main thread running, user-controlled Super Mario with the arrow keys to move the operation, and can achieve Mario game some basic functions, such as stepping on the enemy or top off the bricks. The game uses dual caching technology to solve the game during the splash screen problem. Through the development of this game, to learn Java technology and familiar with software development process purposes.
This paper describes the state of the art related to the development of Java and abroad on the basis of the various development stages of "Super Mario" game for the entire life cycle of a detailed introduction. In order to ensure the correctness of the program code and functions to achieve reliability, this article describes the game software debugging process and functional test results.
Key words: Object-Oriented,java,Collision Detection, Mario
目 录
1、绪论 11
1.1背景以及现状 11
1.2 Java语言的特点 12
1.3 系统运行环境及开发软件： 12
1.4 可行性的分析 13
1.4.1 技术可行性 13
1.4.2 经济可行性 13
1.4.3 操作可行性 14
2、 需求分析 14
2.1 用户需求分析 14
2.2功能需求分析 15
2.3界面设计需求分析 15
3、 系统概要设计 16
3.1系统模块设计 16
3.1.1窗体类 16
3.1.2初始化类 17
3.1.3背景类 18
3.1.4马里奥类 18
3.1.5障碍物类 19
3.1.6敌人类 19
3.2系统流程设计 20
4、 系统详细设计 21
4.1 设计目标 21
4.2 系统模块设计 22
4.2.1窗体类 22
4.2.2初始化类 26
4.2.3背景类 28
4.2.4马里奥类 31
4.2.5障碍物类 37
4.2.6敌人类 39
5、系统的实现 42
5.1游戏开发所需要的图片 42
5.1.1马里奥的所有图片 42
5.1.2游戏中障碍物的图片 43
5.1.3游戏中怪物的图片 44
5.1.4游戏中的背景图片 44
5.1.5游戏开始时的图片 45
5.2游戏设计的界面 45
5.2.1 游戏逻辑展示 45
5.2.1 游戏逻辑展示 46
6、系统测试 48
6.1 测试的意义 48
6.2 测试过程 49
6.3 测试结果 49
7、总结与展望 50
7.1 总结 50
7.2 设计中的不足之处 51
7.3 展望 51
致 谢 52
外文原文 53
外文翻译 57
1、绪论
1.1背景以及现状
随着计算机日益普及，计算机已然成为人们日常生活的一部分的今天，计算机游戏也越来越成为人们生活中不可或缺的元素。游戏可以简单地理解为调节人们生活节奏和缓解人们生活压力的一种手段。现在理解的游戏基本意义都是娱乐性质较浓，要有特定的行为模式，遵循一定规则以达到游戏者目的的行动。游戏的最初目的就是让游戏者（玩家）在游戏中得到放松。游戏一直存在于人类活动中，如今定义的游戏从早期的猜谜游戏，发展到如今的单机RPG游戏，网络游戏等，已经升华为更高级别意义上的娱乐活动，对人们的感官刺激也越发强烈，得到的乐趣也更多。Java并不是以游戏编程为目的而被开发的，事实上，游戏编程可能是Java创造者心中的最后一个目标。在过去，妨碍Java发展的是它的运行环境；浏览器和Java类库一起从本质上决定了Java应该用来写哪种类型的应用程序，而高速的游戏和图象则不在其中。这给Java带来了不好的影响，因为人们注意的不是语言，而是它的运行环境。现在，浏览器已经不能控制一切了，Java作为游戏编程语言的另一个机会到来了。Java在过去有一点超前于它的时代，当时市场的动力落后于Java，但是现在Java可以而且已经取得成功。
1.2 Java语言的特点
1. 平台无关性
Java引进虚拟机原理，并运行于虚拟机，实现不同平台之间的Java接口。使用Java编写的程序能在世界范围内共享。Java的数据类型与机器无关。
2. 安全性
Java的编程类似C++,但舍弃了C++的指针对存储器地址的直接操作，程序运行时，内存由操作系统分配，这样可以避免病毒通过指针入侵系统。它提供了安全管理器，防止程序的非法访问。
3. 面向对象
Java吸收了C++面向对象的概念，将数据封装于类中，实现了程序的简洁性和便于维护性，使程序代码可以只需一次编译就可反复利用。
4. 分布式
Java建立在TCP/IP网络平台上，提供了用HTTP和FTP协议传送和接收信息的库函数，使用其相关技术可以十分方便的构建分布式应用系统。
5. 健壮性
Java致力与检查程序在编译和运行时的错误，并自动回收内存，减少了内存出错的可能性。Java取消了C语言的结构、指针、#define语句、多重继承、goto语句、操作符、重载等不易被掌握的特性，提供垃圾收集器自动回收不用的内存空间。
1.3 系统运行环境及开发软件：
开发环境：Windows 7；
（2）开发工具：eclipse；
（3）编程语言：Java语言；
1.4 可行性的分析
可行性研究的目的，就是用最小的代价在尽可能短的时间内确定问题是否能够解决。要达到这个目的，必须分析几种主要的可能解法的利弊，从而判断原定的系统规模和目标是否现实，系统完成后所能带来的效益是否大到值得投资开发这个系统的程度。因此，可行性研究实质上是要进行一次大大压缩简化了的系统分析和设计的过程，也就是在较高层次上以较抽象的方式进行的系统分析和设计的过程。
1.4.1 技术可行性
本游戏是在Windows 7环境下开发的，一般的机器配置就可以了，对机器本身没有太高的要求，一般当前学校或个人电脑完全可满足要求，环境只需装上jdk 1.4或以上版本就行了，Java是现在全球最时髦的开发工具之一,它拥有一套庞大且完善的类库,内置了其他语言需要靠库甚至是操作系统才能支持的功能,拥有一个虚拟机。NeatBeans IDE 5.5是SUN公司开发的Java可视化集成开发工具，是目前最优秀的Java集成开发工具之一。
1.4.2 经济可行性
由于本系统使用到的工具一般机器都具备，使用环境也很简单，开发成本低，本课题研究的内容是涉及网络的游戏对战。当今形式下网络游戏俨然已经成为年轻人最时兴的消费方式之一，JAVA一直以来由于其可以“跨平台”以及“一次编译，到处运行”等特点，许多人直接它为网络编程语言，且由于JAVA游戏一般来说简单有趣，并且对用户硬件要求极小，所以JAVA游戏通常对85%的计算机用户都有吸引力。且政府态度和政策都是一种信号，表明2005年对本土网络游戏的扶持力度将加大；国内游戏厂商将可获得发展的核心技术平台；政策有利于保护中国游戏软件的自主知识产权；这为网络游戏发展创造了良好的政策环境。
1.4.3 操作可行性
由于在整个系统的开发过程中从操作简便、界面美观、灵活实用的用户要求为出发点，界面设计时充分考虑玩家的感受，界面比较直观，交互性很好，所以操作起来简单明了。
2、需求分析
所谓系统分析，就是指在整个系统开发工程中，解决“做什么”的问题，把要解决哪些问题，满足用户哪些具体的信息需求调查分析清楚，从逻辑上或是说从信息处理的功能需求上提出系统的方案，即逻辑模型，为下一阶段进行物理方案设计，解决怎么办提供依据。
2.1 用户需求分析
超级玛丽这款游戏是很多人童年经典的回忆，是一种简单的大众的游戏，自从计算机实现以来，深受广大电脑玩家的喜爱。并且随着社会的快速发展，人们的生活节奏越来越快，人们对于童年的美好已经不愿意仅仅停留在回忆阶段。所以利用java语言开发一款超级玛丽游戏正是人们迫切需要的。
2.2功能需求分析
本系统主要是完成超级玛丽游戏的基本操作。本系统需要满足以下几点要求：
(1) 在开始界面按空格键进入游戏。
(2) 利用方向键来控制马里奥的运动。
(3) 碰撞检测：
A.马里奥在运动的过程中如果碰到障碍物则停止运动,在移动到悬崖上方是会掉下去，并失去一条生命。
B.对于有些敌人，如果马里奥跳到敌人头顶上，则敌人消失，否则马里奥失去一条生命。
(4)马里奥顶到金币会增加分数，当马里奥失去3条生命时游戏结束。
2.3界面设计需求分析
1) 选取和谐Q版的图片，使画面色彩和谐自然。
2) 固定游戏界面大小与初始显示位置。
3) 游戏采用900*600像素显示，对于马里奥和障碍物选用60*60像素的正
方图片，对于较大的障碍物分割成多个60*60的小正方形。
3、系统概要设计
3.1系统模块设计
首先在对于系统的需求进行了分析，因为设计者的最初是要做一款游戏，所以窗体类必不可少。接下来继续分析，游戏中还需要背景类、障碍物类、敌人类、马里奥类这及格类。其次为了游戏的流畅以及游戏中图片调用的方便，专门为此再设计一个初始化类。
3.1.1窗体类
该类主要用于存放游戏的场景以及其他各类，并且实现KeyListener接口，用于从键盘的按键中读取信息。该类中的一些属性主要包括了用于存放所有场景的list集合 allBG，马里奥类 mario，当前的场景 nowBG以及其他一些游戏中需要的标记等。而且在该类中，运用双缓存的技术使得游戏的流畅度更高，解决了游戏中出现的闪屏问题。
Myframe
- allBG:List
- mario:Mario
- nowBG:BackGround
......
+ main():void
+ paint():void
+ keyPressed():void
+ kerReleased():void
......
3.1.2初始化类
用于存放游戏所需要的所有静态文件，在游戏开始的时候将所有文件导入，提高游戏的运行速度。并且在该类中将所有需要用到的图片进行分类，分为障碍物类，马里奥类，敌人类以及背景图片。当游戏运行时可以直接调用这些集合中的图片进行遍历，在调用的时候更加方便，而且可以使马里奥或者敌人在移动的时候产生动态效果。
StaticValue
+ allMarioImage:List
+ startImage:BufferedImage
......
+ init():void
......
3.1.3背景类
该类表示马里奥及障碍物和敌人所处的场景，并且将障碍物和敌人绘制到场景中。在该类中包括用于存放敌人和障碍物的list集合，以及当敌人或者障碍物被消灭后用于存放已经消失的敌人和障碍物的集合，这样做是为了在马里奥死亡时重置场景所用的。其次在该类中还使用了控制敌人移动的方法，是为了在程序之初控制敌人静止，然后在玩家点击空格以后在使得敌人开始移动。
BackGround
- bgImage:BufferedImage
- isOver:boolean
- isDown:boolean
- allEnemy:List
- removeEnemy:List
......
+ enemyStartMove():void
+ reset():void
......
3.1.4马里奥类
用来控制马里奥的行动，并且在该类中加入碰撞检测，判断马里奥是否与障碍物或者敌人发生碰撞。该类中的属性主要定义了马里奥所在的场景，马里奥的移动和跳跃的速度，以及马里奥在移动过程中需要显示的图片。另外该类中还定义了玩家的生命值和所获得的分数。并且在run（）方法中还定义了当马里奥到达最后一关的旗子时，玩家将失去对马里奥的控制，剩下的由程序控制走到城堡，完整全部游戏。
Mario
- x:int
- y:int
- xmove:int
- ymove;int
- life:int
- isDead:boolean
......
+ leftMove():void
+ leftStop():void
+ jump():void
+ down():void
+ dead():void
......
3.1.5障碍物类
绘制场景中所需要的障碍物，例如地面、砖块、水管等等。该类中的属性包括了障碍物的坐标，障碍物所需要显示的图片等。并且在该类中也定义了障碍物类的重置方法，当马里奥死亡时，场景类会调用该方法。
Obstruction
- x:int
- y:int
- type:int
- starttype:int
- showImage:BufferedImage
......
+ reset():void
+ setImage():void
......
3.1.6敌人类
该类中主要设置了两种敌人，一种是蘑菇怪，可以被马里奥踩死，另一种是食人花，不能被踩死。该类中的属性包括了敌人的坐标，敌人的初始坐标，需要显示的图片，以及敌人的移动方向和移动范围等。敌人的初始坐标主要是为了当敌人执行重置方法后将敌人的位置还原。
Enemy
- x:int
- y:int
- startx:int
- starty:int
- showImage:BufferedImage
- upMax:int
- downMax:int
......
+ reset():void
+ dead():void
......
3.2系统流程设计
4、系统详细设计
4.1 设计目标
本软件是针对超级玛丽小游戏的JAVA程序，进入游戏后首先按空格键开始，利用方向键来控制的马里奥的移动，同时检测马里奥与场景中的障碍物和敌人的碰撞，并判断马里奥的可移动性和马里奥的生命值。当马里奥通过最后一个场景后游戏结束。
4.2 系统模块设计
本系统共包括6各类：
4.2.1窗体类
该类主要用于存放游戏的场景以及其他各类，并且实现KeyListener接口，用于从键盘的按键中读取信息。该类中的一些属性主要包括了用于存放所有场景的list集合 allBG，马里奥类 mario，当前的场景 nowBG以及其他一些游戏中需要的标记等。而且在该类中，运用双缓存的技术使得游戏的流畅度更高，解决了游戏中出现的闪屏问题。
将该类的名字定义为MyFrame，并且要在该类中实现KeyListener接口和Runnable接口。然后首先要在该类中定义一个List集合，集合的泛型为背景类BackGround，集合的名字定义为allBG，用于存放所有的背景。接着定义一个Mario类属性，名字为mario，这个就是游戏运行时候的所需要的mario。接下来还要在类中定义一个BackGround属性，nowBG，默认值应当为空，会在构造方法中赋予该属性初值，这个属性主要是用来存放当前游戏运行时马里奥所处的游戏场景。另外该类中还应该有一个Thread类属性t，这个属性主要是为了在游戏运行的时候控制游戏的线程。然后就可以在类中定义main()方法，将该类实现就可以了。值得一提的是该类的构造方法相对来说是比较复杂的。
在该类的构造方法中，应当首先绘制窗体类的标题，以及窗体类的大小，并且要对窗体类在初始化的时候的位置，也就是在屏幕中显示的位置，最好是显示的时候居中，这样的话在游戏运行时会比较美观一些。其次还要对窗体的一个是否可拉升属性进行一下设置，这个设置的主要目的是因为游戏的界面都是开发者经过深思熟虑考虑出来的比较美观的界面，玩家随意改变游戏的窗口大小可能会对游戏的体验造成影响，所以在这里应该设置游戏的窗体默认不可以被拉伸。
public MyFrame(){
this.setTitle("玛丽奥");
this.setSize(900, 600);
//这里是为了获得电脑屏幕的整体大小，以便于下面确定窗体的位置
int width = Toolkit.getDefaultToolkit().getScreenSize().width;
int height = Toolkit.getDefaultToolkit().getScreenSize().height;
this.setLocation((width-900)/2, (height-600)/2);
//设置窗体默认不可以被拉伸
this.setResizable(false);
//初始化图片
StaticValue.init();
当这些都设置好以后，接下来就应当在构造方法中绘制了，当然最先应当将游戏的场景绘制到窗体类中，然后在窗体类中还应当绘制马里奥类，这是游戏中必不可少的。当然在绘制场景类的时候因为不知一个场景，所以可以使用循环，将所有的场景全部绘制。然后在将所需要的所有监视设置好以后就可以开启该类的线程了。
//使用循环创建全部场景
for(int i=1;i<=7;i++){
this.allBG.add(new BackGround(i, i==7?true:false));
}
//将第一个场景设置为当前场景
this.nowBG = this.allBG.get(0);
//初始化玛丽奥
this.mario = new Mario(0, 480);
//将玛丽奥放入场景中
this.mario.setBg(nowBG);
this.repaint();
this.addKeyListener(this);
this.t = new Thread(this);
t.start();
//使窗口在关闭的时候，程序也同时停止。
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}
在这些最基本的东西设置完以后，还需要一个方法来解决游戏中经常会出现的闪屏问题。这个方法就是双缓存方法，现在类中定义一个BufferedImage的图片，然后从该图片中获取到图片的Graphics g2，然后利用画笔g2将所要绘制的东西绘制到这个空的图片中，然后在利用窗体类中的paint方法中的画笔g将这个已经绘制好的图片绘制到窗体类中，这样利用空白图片作为程序运行中的中转，就可以很好的解决游戏运行过程中出现的闪屏问题。
public void paint(Graphics g) {
//先定义一个图片，然后利用双缓存解决闪屏问题
BufferedImage image = new BufferedImage(900, 600, BufferedImage.TYPE_3BYTE_BGR);
Graphics g2 = image.getGraphics();
//利用上面图片中得到的画笔g2，将所需绘制到图片中
if(this.isStart){
//绘制背景
g2.drawImage(this.nowBG.getBgImage(), 0, 0, this);
//绘制生命
g2.drawString("生命: "+this.mario.getLife(), 800, 50);
//绘制怪物敌人
Iterator
while(iterEnemy.hasNext()){
Enemy e = iterEnemy.next();
g2.drawImage(e.getShowImage(), e.getX(), e.getY(), this);
}
//把缓存图片绘制进去
g.drawImage(image, 0, 0, this);
}
当然游戏的宗旨是让玩家和电脑之间的互动，那么就又涉及到一个问题，就是玩家对游戏中的马里奥的控制。我们前面已经说过了该类中必须要实现KeyListener接口，这个接口的作用就是使该类中实现一些方法，以便于达到玩家在游戏进行时可以对游戏中的马里奥进行控制。我们这里拟定对于马里奥的控制可以使用我们常见的四个方向键，即我们说的上下左右。并且通过控制台打印，可以知道上对应的是38，右对应的是39，左对应的是37。并且游戏的设定是开始后游戏不会直接运行，而是要使用空格键以后游戏才会真正开始，所以还要加入当按空格键的时候游戏正式开始，空格键对应的是32。
public void keyPressed(KeyEvent e) {
if(this.isStart){
//玛丽奥的移动控制
if(e.getKeyCode()==39){
this.mario.rightMove();
}
if(e.getKeyCode()==37){
this.mario.leftMove();
}
//跳跃控制
if(e.getKeyCode()==38){
this.mario.jump();
}
}else if(e.getKeyCode()==32){
this.isStart = true;
}
}
对于按键，那么相对应的就是当抬起建的时候。因为你向右移动的时候，如果这时候突然停止，那么很可能马里奥会保持一个运动的状态停下来，那么就必须在玛丽奥停止的时候给他一个指令，让他的移动图片变为静止。相对于运动的时候是类似的，这里不做累述。
public void keyReleased(KeyEvent e) {
if(this.isStart){
//控制玛丽奥的停止
if(e.getKeyCode()==39){
this.mario.rightStop();;
}
if(e.getKeyCode()==37){
this.mario.leftStop();;
}
}
当这一切都做好以后，那么最后就应该在类中重写一下run方法了，在这个方法中应当提一下游戏的通关和死亡后的状态。即游戏通关，或者马里奥死亡时应当弹出一个窗口，说明游戏通关或者马里奥死亡，并且点击了这个窗口以后，游戏应当结束，而且整个游戏也应当关闭。
if(this.mario.isDead()){
JOptionPane.showMessageDialog(this, "游戏结束");
System.exit(0);
}
if(this.mario.isClear()){
JOptionPane.showMessageDialog(this, "恭喜游戏通关！");
System.exit(0);
}
4.2.2初始化类
用于存放游戏所需要的所有静态文件，在游戏开始的时候将所有文件导入，提高游戏的运行速度。并且在该类中将所有需要用到的图片进行分类，分为障碍物类，马里奥类，敌人类以及背景图片。当游戏运行时可以直接调用这些集合中的图片进行遍历，在调用的时候更加方便，而且可以使马里奥或者敌人在移动的时候产生动态效果。
首先在类中应当定义一个静态的List，泛型为BufferedImage，属性名字为allMarioImage，这个属性的作用在于存放所有的马里奥图片，里面包括了马里奥的移动图片，站立图片以及马里奥跳跃的图片。这样在程序运行的时候就可以从该类中的这个属性里面将所需要的马里奥图片直接调用出来，并且还可以在马里奥移动时不断遍历里面的图片，这样就可以使马里奥产生移动的动态效果。接下来要在该类中定义开始图片，结束图片以及背景图片，默认的初始值都为null。注意这些所有的属性都是静态的，包括下面要提到的所有的属性，这样做的目的是为了在程序运行时先加载这些图片。然后应当定义存放食人花的List集合allFlowerImage，这个集合将食人花的不同形态，张嘴、闭嘴图片存放进去，这样在运行的时候进行遍历就可以打到动态效果。同理存放蘑菇怪的集合allTrangleImage，以及存放所有障碍物的集合allObstructionImage。
public class StaticValue {
public static List
public static BufferedImage startImage = null;
public static BufferedImage endImage = null;
public static BufferedImage bgImage = null;
public static List
public static List
public static List
定义完这些属性之后，剩下的就是初始化了，在该类中定义一个init()方法，这个方法在执行的时候会将所需的所有图片放入到之前定义好的各个集合中。因为图片存放的路径都是一样的，所以为了减少代码量会定义一个公共路径ImagePath。然后就可以利用循环，将存放的图片全部导入进去。
//介绍代码量，定义公共路径
public static String ImagePath = System.getProperty("user.dir")+"/bin/";
//定义方法init()，将图片初始化
public static void init(){
//利用循环将玛丽奥图片初始化
for(int i=1;i<=10;i++){
try {
allMarioImage.add(ImageIO.read(new File(ImagePath+i+".png")));
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//导入背景图片
try {
startImage = ImageIO.read(new File(ImagePath+"start.jpg"));
bgImage = ImageIO.read(new File(ImagePath+"firststage.jpg"));
endImage = ImageIO.read(new File(ImagePath+"firststageend.jpg"));
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//导入玛丽奥死亡图片
try {
mariDeadImage = ImageIO.read(new File(ImagePath+"over.png"));
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
4.2.3背景类
该类表示马里奥及障碍物和敌人所处的场景，并且将障碍物和敌人绘制到场景中。在该类中包括用于存放敌人和障碍物的list集合，以及当敌人或者障碍物被消灭后用于存放已经消失的敌人和障碍物的集合，这样做是为了在马里奥死亡时重置场景所用的。其次在该类中还使用了控制敌人移动的方法，是为了在程序之初控制敌人静止，然后在玩家点击空格以后在使得敌人开始移动。并且在第六个关卡处设置了一个隐形通关要点，只有当马里奥顶到这个隐形砖块时才会出现，马里奥就可以借助这个砖块通过关卡。
首先背景类中肯定要有一个标记来表示现在是第几个场景，因为不同的背景中所绘制的场景，障碍物等也不同，所以该类中要有一个int类型的场景顺序sort。并且在游戏的设定中，如果玩家玩到最有一关的时候马里奥会失去玩家的控制，自己走向城堡。那么这里就要这几一个标记，是否为最后的场景，类型为boolean类型。如果马里奥失去所有生命值，或者游戏通关的话，那么游戏就会结束，这里还应当加一个boolean的标记isOver判断游戏是否结束。
public class BackGround {
//当前场景图片
private BufferedImage bgImage = null;
//场景顺序
private int sort;
//是否为最后的场景
private boolean flag;
//游戏结束标记
private boolean isOver = false;
在最后一个关卡中，马里奥到达旗杆的位置后就会失去控制，同时旗子将会开始下降，只有等旗子下降完毕后，马里奥才能开始移动，所以这里还要定义一个旗子是否下降完毕的boolean类型的属性isDown，用于判断马里奥什么时候移动。
//定义降旗结束
private boolean isDown = false;
当马里奥失去生命的时候，但是并没有失去所有的生命，那么这个时候应当重置这个场景，将所有消灭掉的障碍物和敌人全部还原。因此除了在该类中除了要定义存放敌人和障碍物的List集合以外，还应当有存放被消灭的敌人或者障碍物的List，当敌人或者障碍物被消灭的时候先放入到这个List中，这样在充值的时候就可以直接将这个集合中的数据在还原到原先的集合里面。
//用集合保存敌人
private List
//用集合保存障碍物
private List
//被消灭的敌人
private List
//被消灭的障碍物
private List
在游戏的设定中，应当是游戏开始的时候，所有的敌人其实是静止的，而且玩家也不能控制马里奥，必须要等到玩家按空格键开始以后游戏才会进行，那么这里就应当在定义一个方法，即当玩家空格键的时候会调用这个方法，同时游戏中的敌人开始移动，游戏正式开始。这个方法也就是相当于控制敌人开始移动的方法，所以命名为enemyStartMove()方法。
//敌人开始移动
public void enemyStartMove(){
//遍历当前场景中的敌人，使之开始移动
for(int i=0;i
}
}
接下来就应当定义背景类的构造方法了，通过获取场景的顺序，即场景的sort，来判断是哪一个场景，同时将场景绘制好。
//构造方法
public BackGround(int sort,boolean flag){
//第一个场景
if(sort==1){
for(int i=0;i<15;i++){
this.allObstruction.add(new Obstruction(i*60, 540, 9,this));
}
//绘制砖块和问号
this.allObstruction.add(new Obstruction(120, 360, 4,this));
this.allObstruction.add(new Obstruction(300, 360, 0,this));
......
}
前面提到，如果马里奥死亡，但是却没有失去所有的生命值，那么游戏应当重置，当前场景中的所有敌人和障碍物，也包括马里奥都应当回到初始位置。为了达到这个效果，那么我们的场景类中就必须要定义一个reset()方法，来调用障碍物和场景还有马里奥的各自的重置方法，来使当前的场景还原。并且在这之前我们还要将消灭掉的敌人和障碍物从消灭掉的存放的List中提出来，放回到原来的List中。然后遍历障碍物和敌人的List，使用循环调用他们的重置方法。
//重置方法,重置障碍物和敌人
public void reset(){
//将移除的障碍物和敌人还原
this.allEnemy.addAll(this.removeEnemy);
this.allObstruction.addAll(this.removeObstruction);
//调用障碍物和敌人的重置方法
for(int i=0;i
}
for(int i=0;i
}
}
4.2.4马里奥类
用来控制马里奥的行动，并且在该类中加入碰撞检测，判断马里奥是否与障碍物或者敌人发生碰撞。该类中的属性主要定义了马里奥所在的场景，马里奥的移动和跳跃的速度，以及马里奥在移动过程中需要显示的图片。另外该类中还定义了玩家的生命值和所获得的分数。并且在run（）方法中还定义了当马里奥到达最后一关的旗子时，玩家将失去对马里奥的控制，剩下的由程序控制走到城堡，完整全部游戏。
在游戏中，玛丽奥要在玩家的控制下完成移动、跳跃等动作，那么这些动作首先肯定要涉及到坐标，那么我们在该类中首先要定义两个属性，这两个属性即为马里奥的坐标x和y。并且该类还要实现Runnable接口，在run()方法中写马里奥的移动规则。
public class Mario implements Runnable{
//坐标
private int x;
private int y;
//定义玛丽奥所在场景
private BackGround bg;
//加入线程
private Thread t = null;
为了玩家在游戏过程中的良好体验，那么对于马里奥的移动速度和跳跃速度就必须要定义好。所以该类里面还应当定义马里奥的移动速度和跳跃速度，其本质就是马里奥在移动过程中坐标加减的值。当然初始值为零，必须等到马里奥构造的时候，再将这些属性赋予相对应的值。在本类中还要定义游戏的分数以及马里奥的生命数，这些都是必不可少的。
//移动速度
private int xmove = 0;
//跳跃速度
private int ymove = 0;
//状态
private String status;
//显示图片
private BufferedImage showImage;
//生命和分数
private int score;
private int life;
在马里奥这个类中，还要定义马里奥的移动和跳跃方法，以便玩家在按下方向键后调用这些方法，来达到控制马里奥的移动。下面是马里奥向左移动的方法，其他方法同理。
public void leftMove(){
//移动速度
xmove = -5;
//改变状态
//如果当前已经是跳跃，应该保持原有状态，不能再改变
if(this.status.indexOf("jumping") != -1){
this.status = "left-jumping";
}else{
this.status = "left-moving";
}
}
......
在定义马里奥的跳跃方法的时候，不单单定义一个方法就行，而且还要判断马里奥的状态。如果马里奥是在地面或者是在障碍物的上方，那么马里奥可以进行跳跃，如果马里奥处于空中，那么马里奥就不可以继续跳跃。
public void jump(){
//判断马里奥是否可以进行跳跃
if(this.status.indexOf("jumping") == -1){
if(this.status.indexOf("left") != -1){
this.status = "left-jumping";
}else{
this.status = "right-jumping";
}
ymove = -5;
upTime = 36;
}
}
接下来就要写马里奥中的run()方法了，这个方法中的内容相对来说比较麻烦，因为要在这个方法中对马里奥和障碍物或者敌人之间进行逻辑判断，即所谓的碰撞检测。首先在这个类中对马里奥是否处于最后一个场景进行判断，如果马里奥处于最后一个场景，并且坐标大于520，那么说明马里奥已经撞到的旗杆，这个时候马里奥将不会由玩家控制。并且同时调用旗子的移动方法，使旗子进行下落，当旗子下落完毕后给马里奥一个标记，马里奥开始移动到城堡。当马里奥的坐标大于780，即马里奥到达城堡的门口的时候，这个时候游戏结束。
public void run() {
while(true){
//判断是否与障碍物碰撞
//定义标记
if(this.bg.isFlag() && this.x >= 520){
this.bg.setOver(true);
if(this.bg.isDown()){
//降旗后玛丽奥开始移
this.status = "right-moving";
if(this.x < 580){
//向右
this.x += 5;
}
if(this.x >= 780){
//游戏结束
this.setClear(true);
}
然后对当前马里奥所处的场景中的所有障碍物进行遍历，获取到所有障碍物的坐标，通过障碍物的坐标和马里奥的坐标的之间的关系的判断，来决定马里奥是否与障碍物发生了碰撞，并且通过判断的结果来对马里奥和障碍物的状态进行相应的变化。
for(int i=0;i
//不能向右移动
if(ob.getX()==this.x+60&&(ob.getY()+50>this.y&&ob.getY()-50
canRight = false;
}
}
......
当马里奥撞到障碍物的时候，那么就要根据障碍物的类型进行接下来的判断，如果是砖块或者是问号的话，那么障碍物消失，马里奥被弹回，即马里奥的状态由上升状态变为下落状态，并且将消失掉的障碍物放入相对应的消失的List集合当中。如果障碍物的类型为其他，比如说是石头的话，那么障碍物不变，马里奥直接被弹回。
//判断玛丽奥跳跃时是否撞到障碍物
if(ob.getY()==this.y-60&&(ob.getX()+50>this.x && ob.getX()-50
if(ob.getType()==0){
//移除砖块
this.bg.getAllObstruction().remove(ob);
//保存到移除的障碍物中
this.bg.getRemoveObstruction().add(ob);
}
为了游戏的可玩性，将会在游戏中加入一个隐藏的陷阱，或者是隐藏的通关点。这个隐藏的障碍物在游戏进行的时候不会显示出来，当然马里奥从他的左右两边过去的时候也不会触发这个隐藏的障碍物，必须是从下方撞到这个障碍物时才会显示出来。同时马里奥由上升状态变为下落状态。而且他和砖块障碍物相同，被顶到后会变为石头，改变类型。
//如果是问号||隐藏的砖块
if((ob.getType()==4 || ob.getType()==3) && upTime > 0){
ob.setType(2);
ob.setImage();
}
//马里奥开始下落
upTime = 0;
在游戏中敌人大致可以分为两类。一类是蘑菇怪，这种敌人是可以被杀死的，当马里奥从蘑菇怪的正上方踩到蘑菇怪时，那么蘑菇怪就会被消灭，同时马里奥向上跳起一小段距离。而消失掉的蘑菇怪就会被放到消失掉的敌人的List集合中，等到重置的时候在调用出来。但是如果马里奥从蘑菇怪的左右两边碰到蘑菇怪的话就会失去一条生命，并且重置游戏。第二类是食人花，这种敌人不会被马里奥消灭掉，不论马里奥从哪个方向去碰撞食人花，食人花都不会消失，而且如果马里奥碰到了食人花，自身还会失去一条生命，并且游戏重置，当然前提是马里奥没有失去所有的生命值，否则的话游戏就结束。
首先马里奥对于所有的敌人，如果从左右两边碰撞到敌人，那么马里奥死亡，失去一条生命，游戏重置。
//对敌人的判断
for(int i=0;i
//对于所有的敌人都适用
if((e.getX()+50>this.x && e.getX()-50
this.dead();
}
//这里开始区分敌人的类别，对于不同的敌人做出不同的反应
if(e.getY()==this.y+60 && (e.getX()+60>this.x && e.getX()-60
e.dead();
this.upTime = 10;
this.ymove = -5;
}else if(e.getType() == 2){
this.dead();
}
}
4.2.5障碍物类
绘制场景中所需要的障碍物，例如地面、砖块、水管等等。该类中的属性包括了障碍物的坐标，障碍物所需要显示的图片等。并且在该类中也定义了障碍物类的重置方法，当马里奥死亡时，场景类会调用该方法。
游戏中的场景是由背景中的障碍物绘制而成的，不同的障碍物所在的位置肯定也不相同，那么对于障碍物而言，就必须要有坐标属性来使绘制的时候将不同的障碍物绘制到不同的位置，所以必须要有两个int属性x和y来表示障碍物的坐标。同时该类也必须要实现Runnable接口，实现这个接口的作用主要是为了在最有一个场景中控制旗子的运动，当然同时还要为该类加入线程。
public class Obstruction implements Runnable{
//坐标
private int x;
private int y;
//控制旗子
private Thread t = new Thread(this);
前面说过，当马里奥顶到问好或者是隐藏的砖块时，那么这个障碍物的类型就会改变，变为石头。那么在障碍物这个类里面就必须要定义一个属性stype，这个属性用于表示当前障碍物的类型，以便于变化形态的时候调用。这个类型的值就可以用初始化类中的相对应的List集合里面的下标表示。既然有改变，就要有恢复，所以还要定义一个不变的type，命名为starttype，这个属性是为了当游戏重置的时候，障碍物可以通过调用这个属性恢复到最初始的状态。而且不同的状态对应不同的显示图片，所以还要有showImage属性。
//类型
private int type;
//初始类型
private int starttype;
//显示图片
private BufferedImage showImage = null;
//取得场景
private BackGround bg;
在该类中还要写入reset()方法，这个方法是为了当马里奥死的时候调用重置方法，对已经被消灭掉的障碍物进行重置。因为有的障碍物被顶掉以后会给变类型和图片，所有还要定义一个setImage()方法，用来改变障碍物的显示图片。
//重置方法
public void reset(){
this.type = starttype;
this.setImage();
}
//根据状态改变显示图片
public void setImage(){
showImage = StaticValue.allObstructionImage.get(type);
}
最后该类中的run方法主要是为了控制最后一个场景中的旗子的移动，并且在旗子移动完毕后要设置一个标记，并且将该标记表示给马里奥类，这样马里奥就可以开始自主移动了。
if(this.bg.isOver()){
if(this.y < 420){
this.y += 5;
}else{
//设计标记为true，即表示马里奥可以开始移动了
this.bg.setDown(true);
}
4.2.6敌人类
该类中主要设置了两种敌人，一种是蘑菇怪，可以被马里奥踩死，另一种是食人花，不能被踩死。该类中的属性包括了敌人的坐标，敌人的初始坐标，需要显示的图片，以及敌人的移动方向和移动范围等。敌人的初始坐标主要是为了当敌人执行重置方法后将敌人的位置还原。
在该类中首先要实现Runnable接口，因为在游戏中的敌人是可以移动的，所以一定要通过重写run()方法来达到敌人可以移动的效果。当然还要在该类中定义一个Thread属性，用于控制线程。然后说说到移动，必然少不了坐标问题，那么在该类中就要定义两个int属性x和y，用于控制敌人的位置以及敌人的移动。
public class Enemy implements Runnable{
//坐标
private int x;
private int y;
//加入线程
private Thread t = null;
当马里奥失去一条生命值的时候，游戏会被重置，敌人回回到初始的位置，所以还要定义另外两个int属性startx和starty，用来当游戏进行重置的时候，可以根据这个初始坐标回复敌人的位置。
//初始坐标
private int startx;
private int starty;
对于不同的敌人，所显示的图片肯定是不同的，所以要定义一个现实的图片属性showImage，并且在马里奥中，马里奥要通过判断敌人的类型，来决定是马里奥死亡，还是敌人死亡，对于不同的敌人有不同的反应，所以还要在该类中定义一个type属性，用来表示敌人的类型。
//怪物类型
private int type;
//显示图片
private BufferedImage showImage;
对于敌人里面的食人花而言，他是在水管中直上直下的，所以他的上下移动应当有一个界限，不论是向上移动还是向下移动，都不能超过这个界限，否则的话食人花就会从水管中飞出来或者是移动到MyFrame外面了。
//移动范围
private int upMax = 0;
private int downMax = 0;
在这个类中应当有两个构造方法，对于不同的敌人，所需要的属性都是不同的。并且在两个类中都有一个共同的代码，那就是要在开启线程后应当先将线程挂起。这是为了配合游戏在开始的时候敌人不移动，必须要等到玩家按空格键的时候才会开始，所以先将线程挂起来，当点击空格键以后在将线程开启。
//蘑菇怪的构造方法
public Enemy(int x,int y,boolean isLeft,int type,BackGround bg){
... ...
this.t = new Thread(this);
t.start();
t.suspend();
}
接下来是写敌人类中的run()方法了，该方法主要是为了控制蘑菇怪以及食人花敌人的移动的。因为不同的敌人在不同的场景中有不同的移动方法，所以对于敌人的移动而且，首先要判断敌人的类型和敌人所处的场景。
public void run() {
while(true){
//判断怪物类型
if(type==1){
if(this.isLeftOrUp){
this.x -= 5;
}else{
this.x += 5;
}
... ...
在游戏中，当马里奥死亡的时候会对整个场景中的障碍物进行重置，当然敌人也不例外。当马里奥死亡的时候，不仅要将所有被消灭的敌人全部显示出来，即从消灭的List中还原到原来的敌人List中，并且敌人的状态和坐标也要进行重置。要将敌人的坐标还原到最开始的坐标，而且把图片进行还原。并且在重置方法中也要对敌人的类型进行判断，使得敌人的类型和他的显示图片相对应。
public void reset(){
//还原坐标
this.x = this.startx;
this.y = this.starty;
//还原图片
if(this.type == 1){
this.showImage = StaticValue.allTriangleImage.get(0);
}else if(this.type == 2){
this.showImage = StaticValue.allFlowerImage.get(0);
}
}
最后在该类中定义一个死亡方法，主要是针对蘑菇怪被消灭的时候所调用的方法。在这个方法中要定义蘑菇怪死亡的时候的显示图片，也就是蘑菇怪被踩扁的图片。并且要将这个敌人从相对应的场景的敌人集合中除去，放入别消灭的敌人的List集合。
public void dead(){
//死亡图片
this.showImage = StaticValue.allTriangleImage.get(2);
//从原来的List集合中删除，让入被消灭的List集合中
this.bg.getAllEnemy().remove(this);
this.bg.getRemoveEnemy().add(this);
}
}
5、系统的实现
5.1游戏开发所需要的图片
5.1.1马里奥的所有图片
这组图片中包含了马里奥的移动，跳跃以及死亡的图片：
A.马里奥向左移动的图片
B.马里奥向左跳跃的图片
C.马里奥向右移动的图片
D.马里奥向右跳跃的图片
E.马里奥死亡的图片
5.1.2游戏中障碍物的图片
这组图片中包含了游戏中的各种障碍物，以及最后通过关卡的旗帜图片还有设置陷阱的隐形图片：
A.地面及普通障碍物图片
B.用于设置陷阱的隐形图片
C.水管类图片
D.最后场景中的旗帜图片
5.1.3游戏中怪物的图片
这组图片中包含了游戏中所有的敌人图片，以及敌人被消灭时的图片：
A.食人花的图片
B蘑菇怪的图片以及被消灭时的图片.
C.乌龟的图片以及被消灭时的图片
5.1.4游戏中的背景图片
这组图片中有一张游戏中的背景图片（图5.1）和一张马里奥通关时的最后一关的背景图片（图5.2）：
图5.1 图5.2
5.1.5游戏开始时的图片
在游戏的最开始会显示该图片（图5.3），然后玩家按空格键开始游戏，之后游戏才正式开始运行。
图5.3
5.2游戏设计的界面
5.2.1 游戏逻辑展示
这一组图片中包括了一些系统中的逻辑图片，如马里奥的控制移动示例图片（图5.4），玩家通过方向键控制马里奥的移动、跳跃等功能；马里奥与障碍物进行碰撞之后的效果图片（图5.5），这张图片中显示了马里奥再与障碍物碰撞后，问号会消失变成石头，而且砖块会被撞碎；玩家控制游戏开始的图片（图5.6），游戏打开后并不会立即运行，必须等到玩家按空格键启动游戏后游戏才会正式开始；当马里奥失去所有的生命以后，游戏结束（图5.7）；如果马里奥顺利通过所有关卡，那么游戏同样结束（图5.8）。
图5.4 图5.5
图5.6 图5.7
图5.8
5.2.1 游戏逻辑展示
这一组图片中主要对游戏的关卡进行展示，其中包括第一关（图5.9），马里奥顺利通过第一管来到第二关（图5.10），第三关的场景（图5.11），第四关的大悬崖场景（图5.12），第五关的场景借鉴了魂斗罗（图5.13），第六关的高墙（图5.14），在这一个关卡中为了提升游戏的可玩性，加了一个隐藏的过关要点，只有找到这个要点才能通过（图5.15），第七关也是最后一关的场景（图5.16）。
图5.9 图5.10
图5.11 图5.12
图5.13 图5.14
图5.15 图5.16
6、系统测试
6.1 测试的意义
系统测试是为了发现错误而执行程序的过程，成功的测试是发现了至今尚未发现的错误的测试。 测试的目的就是希望能以最少的人力和时间发现潜在的各种错误和缺陷。应根据开发各阶段的需求、设计等文档或程序的内部结构精心设计测试用例，并利用这些实例来运行程序，以便发现错误。系统测试是保证系统质量和可靠性的关键步骤，是对系统开发过程中的系统分析系统设计和实施的最后复查。根据测试的概念和目的，在进行信息系统测试时应遵循以基本原则。
6.2 测试过程
(1)拟定测试计划。在制定测试计划时，要充分考虑整个项目的开发时间和开发进童以及一些人为因素和客观条件等，使得测试计划是可行的。测试计划的内容主要有测试的内容、进度安排、测试所需的环境和条件、测试培训安排等。
(2)编制测试大纲。测试大纲是测试的依据。它明确详尽地规定了在测试中针对系统的每一项功能或特性所必须完成的基本测试项目和测试完成的标准。
(3)根据测试大纲设计和生成测试用例。在设计测试用例的时候，可综合利用前面介绍的测试用例和设计技术，产生测试设计说明文档，其内容主要有被测项目、输人数据、测试过程、预期输出结果等。
(4)实施测试。测试的实施阶段是由一系列的测试周期组成的。在每个测试周期中，测试人员和开发人员将依据预先编制好的测试大纲和准备好的测试用例，对被测软件或设备进行完整的测试。
(5)生成测试报告。测试完成后，要形成相应的测试报告，主要对测试进行概要说明，列出测试的结论，指出缺陷和错误，另外，给出一些建议，如可采用的修改方法，各项修改预计的工作量及修改的负责人员。
6.3 测试结果
程序运行正常，没有发现什么太大的错误。
7、总结与展望
7.1 总结
本次设计已是大学最后一次对专业知识的综合实践活动，同时也是我所做的工作量最大的一次作业，因此从一开始我对本次毕业设计就给予了高度重视。从选题、收集资料、学习相关技术到实际编程，我都一丝不苟的对待了。当然其间我也走了不少弯路，有时甚至需要推倒重来，但同时我也多次体会过克服困难后的成就感。
通过这次毕业设计以及撰写本毕业论文，我学会了一些编程技巧，而且对调试的错误有进一步的认识，有时候就一个小小的语法错误就会导致程序调试不通过。所以每个字符，每句程序都要认真对待。使用不同的编程环境，其效率完全不一样，所以我选择了Eclipse,它自动找错/纠错功能、Debug调试和代码自动生成等一些重要的功能大大提高了我的设计效率。
7.2 设计中的不足之处
本系统实现了超级玛丽游戏所应有的基本功能，我对这样的软件开发还只是一个开始，了解的不多，时间和能力有限，还有一部分功能未能实现，如吃到蘑菇会变大，或者吃到花朵可以发子弹，还有就是一些其他的怪物类。因此做的不是很好，游戏的场景设计和布局还比较简单，有些模块和功能的设计不是那么的完善，没有突出特色出来，这也可能是我这个程序的不足之处。
7.3 展望
本系统基本实现了超级玛丽游戏所应有的基本功能，在大学中最后一次专攻式的学习了Java语言，使我对Java语言有了更深层次的理解，通过该游戏设计，提高了我的编程能力，也让我养成了良好的编程习惯。这个次的毕业设计当然也使自己深深的认识到了java这门语言的博大精深，希望将来在工作中能够不断学习，不断进步，逐步的通过自己的积累去慢慢的学习，慢慢的融汇这门语言，争取早日成为能独当一面的java技术开发人才。
致 谢
经过一两个月的忙碌和工作，本次毕业设计业已完成了，作为一个本科生的毕业设计，由于经验的匮乏和业务逻辑的不熟悉，难免有许多考虑不周全和不完善的地方，但是在指导老师.任课老师和同学的帮助下很多困难都得以解决，所以在此本人要特别感谢他们对我的帮助。
首先我要感谢我的学校指导老师，感谢他们在整个毕业设计过程中的指导，为我提示游戏设计的逻辑思路；为我提供参考书籍；为我提供了技术方面资料，而且在遇到问题的时候，总是鼓励我去解决；尤其在论文格式的修改方面，让我明白了要写出一个标准的论文，它的格式的重要性，哪怕就算是一个标点符号都要符合其标准和格式要求。在设计的整个过程中从最初的毕业设计题目的选定，以及中期检查，以及定稿的过程中都给予了我细心的指导。
其次还要特别感谢大学四年来所有的老师，为我们打下计算机专业知识的基础。以前总是觉得学的课程没有什么用处，但是当真正用计算机来解决实际问题的时候，才知道每门课程的重要性，甚至觉得所学习的那些课程还远远不够，所以以后还应该不断的学习。也可以这么说要不是你们在大学四年中严格要求我们，现在要完成整个毕业设计那是根本不可能的。
再次，感谢我们班级的几位同学，在我遇到一些难以解决的问题时，给与我支持，鼓励和帮助，在论文撰写过程中，认真仔细的帮我修改，包括一些难以发觉的语法，符号错误，使我受益匪浅。
最后感谢我的院系和我的母校——太原理工大学软件学院这四年来对我的精心培养。
外文原文
Java Fundamentals
The rise of the Internet and the World Wide Web have fundamentally reshaped computing. Only a few short years ago, the cyber landscape was dominated by stand-alone PCs. Today, nearly all PCs are connected to the Internet. The Internet, itself, was transformed—originally offering a convenient way to share files and information, today it is a vast, distributed computing universe. These changes have been as rapid as they have been profound, and in their wake, they gave rise to a new way to program: Java. Java is the preeminent language of the Internet, but it is more than that. Java has revolutionized programming, changing the way that we think about both the form and the function of a program. To be a professional programmer today implies the ability to program in Java—it has become that important. In the course of this book, you will learn the skills needed to master it. The purpose of this module is to introduce you to Java, including its history, its design philosophy, and several of its most important features. By far, the hardest thing about learning a programming language is the fact that no element exists in isolation. Instead, the components of the language work in conjunction with each other. This interrelatedness is especially pronounced in Java. In fact, it is difficult to discuss one aspect of Java without involving others. To help overcome this problem, this module provides a brief overview of several Java features, including the general form of a Java program, some basic control structures, and operators. It does not go into too many details but, rather, concentrates on the general concepts common to any Java program. 1.1 The Origins of Java .
Computer language innovation is driven forward by two factors: improvements in the art of programming and changes in the computing environment. Java is no exception. Building upon the rich legacy inherited from C and C++, Java adds refinements and features that reflect the current state of the art in programming. Responding to the rise of the online environment, Java offers features that streamline programming for a highly distributed architecture.
Java was conceived by James Gosling, Patrick Naughton, Chris Warth, Ed Frank, and Mike Sheridan at Sun Microsystems in 1991. This language was initially called “Oak” but was renamed “Java” in 1995. Somewhat surprisingly, the original impetus for Java was not the Internet! Instead, the primary motivation was the need for a platform-independent language that could be used to create software to be embedded in various consumer electronic devices, such as toasters, microwave ovens, and remote controls.
As you can probably guess, many different types of CPUs are used as controllers. The trouble was that most computer languages are designed to be compiled for a specific target. For example, consider C++.
Although it is possible to compile a C++ program for just about any type of CPU, to do so requires a full C++ compiler targeted for that CPU. The problem, however, is that compilers are expensive and time-consuming to create. In an attempt to find a better solution, Gosling Java Fundamentals and others worked on a portable, cross-platform language that could produce code that would run on a variety of CPUs under differing environments. This effort ultimately led to the creation of Java.
About the time that the details of Java were being worked out, a second, and ultimately more important, factor emerged that would play a crucial role in the future of Java. This second force was, of course, the World Wide Web. Had the Web not taken shape at about the same time that Java was being implemented, Java might have remained a useful but obscure language for programming consumer electronics. However, with the emergence of the Web, Java was propelled to the forefront of computer language design, because the Web, too, demanded portable programs.
Most programmers learn early in their careers that portable programs are as elusive as they are desirable. While the quest for a way to create efficient, portable (platform-independent) programs is nearly as old as the discipline of programming itself, it had taken a back seat to other, more pressing problems. However, with the advent of the Internet and the Web, the old problem of portability returned with a vengeance. After all, the Internet consists of a diverse, distributed universe populated with many types of computers, operating systems, and CPUs.What was once an irritating but a low-priority problem had become a high-profile necessity.
By 1993 it became obvious to members of the Java design team that the problems of portability frequently encountered when creating code for embedded controllers are also found when attempting to create code for the Internet. This realization caused the focus of Java to switch from consumer electronics to Internet programming. So, while it was the desire for an architecture-neutral programming language that provided the initial spark, it was the Internet that ultimately led to Java’s large-scale success.
How Java Relates to C and C++
Java is directly related to both C and C++. Java inherits its syntax from C. Its object model is adapted from C++. Java’s relationship with C and C++ is important for several reasons. First, many programmers are familiar with the C/C++ syntax. This makes it easy for a C/C++ programmer to learn Java and, conversely, for a Java programmer to learn C/C++.
Second, Java’s designers did not “reinvent the wheel.” Instead, they further refined an
already highly successful programming paradigm. The modern age of programming began with C. It moved to C++, and now to Java. By inheriting and building upon that rich heritage, Java provides a powerful, logically consistent programming environment that takes the best of the past and adds new features required by the online environment. Perhaps most important, because of their similarities, C, C++, and Java define a common, conceptual framework for the professional programmer. Programmers do not face major rifts when switching from one language to another.
One of the central design philosophies of both C and C++ is that the programmer is in charge! Java also inherits this philosophy. Except for those constraints imposed by the Internet environment, Java gives you, the programmer, full control. If you program well, your programs reflect it. If you program poorly, your programs reflect that, too. Put differently, Java is not a language with training wheels. It is a language for professional programmers.
Java has one other attribute in common with C and C++: it was designed, tested, and refined by real, working programmers. It is a language grounded in the needs and experiences of the people who devised it. There is no better way to produce a top-flight professional programming language.
Because of the similarities between Java and C++, especially their support for objectoriented programming, it is tempting to think of Java as simply the “Internet version of C++.” However, to do so would be a mistake. Java has significant practical and philosophical differences. Although Java was influenced by C++, it is not an enhanced version of C++. For example, it is neither upwardly nor downwardly compatible with C++. Of course, the similarities with C++ are significant, and if you are a C++ programmer, you will feel right at home with Java. Another point: Java was not designed to replace C++. Java was designed to solve a certain set of problems. C++ was designed to solve a different set of problems. Both will coexist for many years to come.
How Java Relates to C#
Recently a new language called C# has come on the scene. Created by Microsoft to support its .NET Framework, C# is closely reated to Java. In fact, many of C#’s features were directly adapted from Java. Both Java and C# share the same general C++-style syntax, support distributed programming, and utilize the same object model. There are, of course, differences between Java and C#, but the overall “look and feel” of these languages is very similar. This means that if you already know C#, then learning Java will be especially easy. Conversely, if C# is in your future, then your knowledge of Java will come in handy. Given the similarity between Java and C#, one might naturally ask, “Will C# replace Java?” The answer is No. Java and C# are optimized for two different types of computing environments.
Just as C++ and Java will co-exist for a long time to come, so will C# and Java. 1.2 Java’s Contribution to the Internet
The Internet helped catapult Java to the forefront of programming, and Java, in turn, has had a profound effect on the Internet. The reason for this is quite simple: Java expands the universe of objects that can move about freely in cyberspace. In a network, there are two very broad categories of objects that are transmitted between the server and your personal computer: passive information and dynamic, active programs. For example, when you read your e-mail, you are viewing passive data. Even when you download a program, the program’s code is still only passive data until you execute it. However, a second type of object can be transmitted to your computer: a dynamic, self-executing program. Such a program is an active agent on the client computer, yet it is initiated by the server. For example, a program might be provided by the server to properly display the data that it is sending.
As desirable as dynamic, networked programs are, they also present serious problems in the areas of security and portability. Prior to Java, cyberspace was effectively closed to half of the entities that now live there. As you will see, Java addresses those concerns and, in doing so, has defined a new form of program: the applet.
Java Applets and Applications
Java can be used to create two types of programs: applications and applets. An application is a program that runs on your computer, under the operating system of that computer. An application created by Java is more or less like one created using any other type of computer language, such as Visual Basic or C++. When used to create applications, Java is not much different from any other computer language. Rather, it is Java’s ability to create applets that makes it important. An applet is an application designed to be transmitted over the Internet and executed by a Java-compatible Web browser. Although any computer language can be used to create an application, only Java can be used to create an applet. The reason is that Java solves two of the thorniest problems associated with applets: security and portability. Before continuing, let’s define what these two terms mean relative to the Internet.
Security
As you are almost certainly aware, every time you download a “normal” program, you are risking a viral infection. Prior to Java, most users did not download executable programs frequently, and those that did, scanned them for viruses prior to execution. Even so, most users still worried about the possibility of infecting their systems with a virus or allowing a malicious program to run wild in their systems. (A malicious program might gather private information, such as credit card numbers, bank account balances, and passwords by searching the contents of your computer’s local file system.) Java answers these concerns by providing a firewall between a networked application and your computer.
When using a Java-compatible web browser, it is possible to safely download Java applets without fear of viral infection. The way that Java achieves this is by confining a Java program to the Java execution environment and not allowing it access to other parts of the computer. (You will see how this is accomplished, shortly.) Frankly, the ability to download applets with confidence that no harm will be done to the client computer is the single most important aspect of Java.
Portability
As discussed earlier, many types of computers and operating systems are connected to the Internet. For programs to be dynamically downloaded to all of the various types of platforms, some means of generating portable executable code is needed. As you will soon see, the same mechanism that helps ensure security also helps create portability. Indeed, Java’s solution to these two problems is both elegant and efficient.
外文翻译
Java的基础知识
因特网和万维网的崛起从根本上重塑了计算。仅短短几年前，网络的景观主要是由独立的个人电脑。今天，几乎所有的个人计算机连接到互联网。互联网本身，转化，最初提供一个便捷的方式来共享文件和信息，今天它是一个庞大的，分布式计算宇宙。这些变化已经为快速，因为他们已经深刻的，并在他们之后，他们就产生了一种新的方式来计划：Java的。 Java是互联网的卓越的语言，但它是不止于此。 Java已经彻底改变编程，改变了我们思考的形式和程序的功能的方法。要成为一个专业的程序员今天暗示着编程能力的Java已经成为非常重要的。在这本书的过程中，您将学习如何掌握它所需的技能。该模块的目的是向你介绍Java的，包括它的历史，它的设计理念，它的几个最重要的特点。到目前为止，大约学习一门编程语言中最难的事情是，没有元素是孤立存在的事实。相反，在相互配合的语言工作的组件。这种相互关联是在Java中格外突出。事实上，它是很难讨论的Java的一个方面，而不涉及其他人。为了帮助克服这个问题，该模块提供的多个Java功能，包括Java程序的一般形式，一些基本的控制结构，和运营商的简要概述。它不会进入太多的细节，而是集中在常见的Java程序的一般概念。Java1.1的起源。
计算机语言创新向前驱动由两个因素：改进编程和变化的计算环境的领域中。 Java也不例外。经富遗留从C和C ++继承建筑物，爪哇增加精炼和功能，反映本领域中的编程的当前状态。应对网络环境的兴起，Java提供了简化编程高度分布式架构的特点。
Java是在1991年构思是由詹姆斯•高斯林，帕特里克•诺顿，克里斯•瓦尔特，艾德•弗兰克和麦克谢里丹在Sun Microsystems这种语言最初被称为“橡树”，但更名为“Java”的在1995年出人意料的，对Java的原始动力不上网！相反，主要的动机是，需要一种与平台无关的语言，可用于创建软件要被嵌入在各种消费电子设备，如烤面包机，微波炉，和遥控器。
正如你可能已经猜到，许多不同类型的CPU被用作控制器。麻烦的是，大多数计算机语言被设计为被编译为一个特定的目标。例如，考虑C ++。
虽然可以编译C ++程序几乎任何类型的CPU，这样做需要一个完整的C ++编译器针对该CPU。然而问题是，编译器是昂贵和费时的创建。在试图找到一个更好的解决方案，高斯林的Java基础和他人一起在一个便携式的，跨平台的语言，可以产生不同会在环境上运行的各种CPU的代码。这种努力最终导致建立的Java。
关于Java的细节正在拟定中，第二，最终更重要的时候，出现的因素将在Java的未来起着至关重要的作用。这第二种力量是的，当然，万维网。有网络尚未形成大约在同一时间，Java是正在实施，Java的可能仍然是编程消费电子有用的，但晦涩的语言。然而，随着网络的出现，Java是推进到计算机语言设计的最前沿，因为Web，也要求移植的程序。
大多数程序员学会在其职业生涯早期的便携式程序一样难以捉摸，因为它们是可取的。而追求一种方法来创建高效，可移植（平台无关）方案几乎是一样古老节目本身的学科，它已经退居到其他更紧迫的问题。然而，随着因特网和Web的出现，可移植性的老问题与报复返回。毕竟，互联网由一个多元化，分散居住的宇宙有许多类型的计算机，操作系统，以及CPUs.What曾经是一个刺激，但低优先级的问题已经成为一个备受瞩目的必要性。
到1993年，很明显到便携性的问题创造了嵌入式控制器代码时也发现试图创建代码为上网的时候经常遇到的Java的设计团队的成员。这导致实现了Java的重点从消费电子切换到Internet编程。因此，尽管它是为所提供的初始火花的架构中立编程语言的愿望，这是最终导致Java的大规模成功的互联网。
Java如何涉及到C和C ++
Java的直接关系到C和C ++。 Java的继承了它的语法C.从它的对象模型是改编自C ++。使用C和C ++ Java的关系是有几个原因的重要。首先，许多程序员都熟悉C / C ++的语法。这很容易让一个C / C ++程序员学习Java，相反，对于一个Java程序员学习C / C ++。
Java的设计者并没有“推倒重来。”相反，他们进一步细化了已经非常成功的编程范式。编程的现代时代开始与C.它移动到C ++，现在到Java。通过继承并在这丰富的文物建筑，Java提供了一个强大的，在逻辑上是一致的编程环境，以最佳的过去，并增加了网络环境所需要的新功能。也许最重要的，因为他们的相似之处，C，C ++和Java的，定义为专业的程序员共同的，概念框架。从一种语言到另一种切换时的程序员不面临着重大分歧。
其中C和C ++的核心设计理念是程序员负责！ Java也继承了这一理念。除了通过互联网环境施加的这些限制，Java的给你，程序员，完全控制。如果你的程序顺利，你的程序反映它。如果你的程序不好，你的计划反映出这一点。换句话说，Java是不是与训练车轮的语言。这是适合专业程序员的语言。
Java有一个共同点，其他的属性与C和C ++：它的设计，测试，并通过真实的，工作的程序员细化。它是在需要和谁设计它的人的经验，接地的语言。有没有更好的方式来产生第一流的专业编程语言。
由于Java和C ++，尤其是他们对面向对象编程的支持之间的相似性，很容易让人想到Java作为简单的“C ++的互联网版本。”不过，这样做将是一个错误。 Java有显著实践和哲学的差异。尽管Java是受到C ++，它不是C ++的增强版。例如，它既不向上也不使用C ++向下兼容。当然，C ++是显著的，如果你是一个C ++程序员，你会感到宾至如归与Java的相似之处。还有一点：Java是不是设计来取代C ++。 Java被设计来解决一组特定的问题。 C ++的目的是要解决不同的问题。双方将共存很多年的到来。
Java如何涉及到C＃
最近，一个新的语言称为C＃已经来到现场。创建由微软支持其.NET框架，C＃是密切reated到Java。事实上，许多C＃的特点是直接改编自爪哇。 Java和C＃的份额大致相同的C ++ - 风格的语法，支持分布式编程，并利用相同的对象模型。有，当然，Java和C＃之间的差异，但总的“外观和感觉”这些语言是非常相似的。这意味着，如果你已经知道C＃，然后学习Java将是特别容易。相反，如果C＃是在你的未来，那么你的Java知识就派上用场了。鉴于Java和C＃之间的相似性，人们自然会问，“请问C＃取代Java？”答案是号Java和C＃是两种不同类型的计算环境的优化。
正如C ++和Java共存很长一段时间来，所以将C＃和Java。 1.2 Java的贡献上网互联网帮助弹射器的Java编程的最前沿，和Java，反过来，已在互联网上产生深远的影响。这样做的原因很简单：Java的扩展，可以在网络空间自由走动对象的宇宙。在网络中，有两个非常广阔对象的类别，在服务器和个人电脑之间传输：被动的信息和动态，活动程序。例如，当你阅读电子邮件，您正在查看被动数据。甚至当你下载一个程序，该程序的代码仍然是被动的唯一数据，直到你执行它。然而，第二类型的对象可以被发送到计算机：一个动态的，自动执行的程序。这样的程序是在客户端计算机上的活性剂，但它是由服务器发起的。例如，一个程序可能会被提供该服务器能够正确显示它正在发送数据。
作为理想的动态，网络程序，它们也是在安全性和便携性方面存在严重问题。在此之前的Java，网络空间被有效封闭半，现在生活在那里的实体。正如你所看到的，Java的解决了这些问题，并在此过程中，已定义的节目的新形式：小程序。
Java applet和应用
Java可以被用来创建两种方案：应用程序和applets。一个应用程序是运行在您的计算机上，在那台电脑的操作系统的程序。在Java创建的应用程序或多或少像一个使用的任何其他类型的计算机语言，创建如Visual Basic或C ++。当用于创建应用程序，Java是不是从任何其他计算机语言太大的不同。相反，它是Java的创建小应用程序，使得它重要的能力。一个applet是设计成可通过互联网传送和由Java兼容的Web浏览器上执行的应用。虽然任何计算机语言可以用来创建应用程序，只可以用Java创建applet。其原因是，Java的解决了两个与小程序有关的最棘手的问题：安全性和便携性。在继续之前，让我们来定义什么这两个词的意思是相对于上网。
安全性
当你几乎肯定是知道的，每次你下载一个“正常”的程序时，你冒着被病毒感染。在此之前的Java，大多数用户没有下载可执行程序频繁，而那些确实，在执行之前扫描他们的病毒。即便如此，大多数用户还是担心自己感染系统的病毒或允许恶意程序在其系统上运行野生的可能性。 （恶意程序可能会收集私人信息，如信用卡号码，银行账户余额，并通过搜索计算机的本地文件系统的内容，密码）。通过联网的应用程序和计算机之间提供防火墙的Java回答这些问题。
当使用一个Java兼容的web浏览器，能够安全地下载Java小应用程序，而不必担心病毒感染。了Java实现此的方式是通过限制Java程序的Java执行环境，不允许它访问计算机的其他部分。 （你会看到这是如何实现的，很快。）坦率地说，下载小程序有信心的能力，没有损害将完成到客户端计算机是Java的一个最重要的方面。
可移植性
如前面所讨论的，许多类型的计算机和操作系统的连接到互联网。对于方案被动态地下载到所有不同类型的平台的，产生可移植可执行代码的一些手段是必要的。正如你很快就会看到，同样的机制，有助于确保安全性也有助于创造的便携性。事实上，Java的解决了这两大问题，是既优雅又高效。
7、总结与展望
7.1 总结
本次设计已是大学最后一次对专业知识的综合实践活动，同时也是我所做的工作量最大的一次作业，因此从一开始我对本次毕业设计就给予了高度重视。从选题、收集资料、学习相关技术到实际编程，我都一丝不苟的对待了。当然其间我也走了不少弯路，有时甚至需要推倒重来，但同时我也多次体会过克服困难后的成就感。
通过这次毕业设计以及撰写本毕业论文，我学会了一些编程技巧，而且对调试的错误有进一步的认识，有时候就一个小小的语法错误就会导致程序调试不通过。所以每个字符，每句程序都要认真对待。使用不同的编程环境，其效率完全不一样，所以我选择了Eclipse,它自动找错/纠错功能、Debug调试和代码自动生成等一些重要的功能大大提高了我的设计效率。
7.2 设计中的不足之处
本系统实现了超级玛丽游戏所应有的基本功能，我对这样的软件开发还只是一个开始，了解的不多，时间和能力有限，还有一部分功能未能实现，如吃到蘑菇会变大，或者吃到花朵可以发子弹，还有就是一些其他的怪物类。因此做的不是很好，游戏的场景设计和布局还比较简单，有些模块和功能的设计不是那么的完善，没有突出特色出来，这也可能是我这个程序的不足之处。
7.3 展望
本系统基本实现了超级玛丽游戏所应有的基本功能，在大学中最后一次专攻式的学习了Java语言，使我对Java语言有了更深层次的理解，通过该游戏设计，提高了我的编程能力，也让我养成了良好的编程习惯。这个次的毕业设计当然也使自己深深的认识到了java这门语言的博大精深，希望将来在工作中能够不断学习，不断进步，逐步的通过自己的积累去慢慢的学习，慢慢的融汇这门语言，争取早日成为能独当一面的java技术开发人才。
致 谢
经过一两个月的忙碌和工作，本次毕业设计业已完成了，作为一个本科生的毕业设计，由于经验的匮乏和业务逻辑的不熟悉，难免有许多考虑不周全和不完善的地方，但是在指导老师.任课老师和同学的帮助下很多困难都得以解决，所以在此本人要特别感谢他们对我的帮助。
首先我要感谢我的学校指导老师，感谢他们在整个毕业设计过程中的指导，为我提示游戏设计的逻辑思路；为我提供参考书籍；为我提供了技术方面资料，而且在遇到问题的时候，总是鼓励我去解决；尤其在论文格式的修改方面，让我明白了要写出一个标准的论文，它的格式的重要性，哪怕就算是一个标点符号都要符合其标准和格式要求。在设计的整个过程中从最初的毕业设计题目的选定，以及中期检查，以及定稿的过程中都给予了我细心的指导。
其次还要特别感谢大学四年来所有的老师，为我们打下计算机专业知识的基础。以前总是觉得学的课程没有什么用处，但是当真正用计算机来解决实际问题的时候，才知道每门课程的重要性，甚至觉得所学习的那些课程还远远不够，所以以后还应该不断的学习。也可以这么说要不是你们在大学四年中严格要求我们，现在要完成整个毕业设计那是根本不可能的。
再次，感谢我们班级的几位同学，在我遇到一些难以解决的问题时，给与我支持，鼓励和帮助，在论文撰写过程中，认真仔细的帮我修改，包括一些难以发觉的语法，符号错误，使我受益匪浅。
最后感谢我的院系和我的母校——太原理工大学软件学院这四年来对我的精心培养。
外文原文
Java Fundamentals
The rise of the Internet and the World Wide Web have fundamentally reshaped computing. Only a few short years ago, the cyber landscape was dominated by stand-alone PCs. Today, nearly all PCs are connected to the Internet. The Internet, itself, was transformed—originally offering a convenient way to share files and information, today it is a vast, distributed computing universe. These changes have been as rapid as they have been profound, and in their wake, they gave rise to a new way to program: Java. Java is the preeminent language of the Internet, but it is more than that. Java has revolutionized programming, changing the way that we think about both the form and the function of a program. To be a professional programmer today implies the ability to program in Java—it has become that important. In the course of this book, you will learn the skills needed to master it. The purpose of this module is to introduce you to Java, including its history, its design philosophy, and several of its most important features. By far, the hardest thing about learning a programming language is the fact that no element exists in isolation. Instead, the components of the language work in conjunction with each other. This interrelatedness is especially pronounced in Java. In fact, it is difficult to discuss one aspect of Java without involving others. To help overcome this problem, this module provides a brief overview of several Java features, including the general form of a Java program, some basic control structures, and operators. It does not go into too many details but, rather, concentrates on the general concepts common to any Java program. 1.1 The Origins of Java .
Computer language innovation is driven forward by two factors: improvements in the art of programming and changes in the computing environment. Java is no exception. Building upon the rich legacy inherited from C and C++, Java adds refinements and features that reflect the current state of the art in programming. Responding to the rise of the online environment, Java offers features that streamline programming for a highly distributed architecture.
Java was conceived by James Gosling, Patrick Naughton, Chris Warth, Ed Frank, and Mike Sheridan at Sun Microsystems in 1991. This language was initially called “Oak” but was renamed “Java” in 1995. Somewhat surprisingly, the original impetus for Java was not the Internet! Instead, the primary motivation was the need for a platform-independent language that could be used to create software to be embedded in various consumer electronic devices, such as toasters, microwave ovens, and remote controls.
As you can probably guess, many different types of CPUs are used as controllers. The trouble was that most computer languages are designed to be compiled for a specific target. For example, consider C++.
Although it is possible to compile a C++ program for just about any type of CPU, to do so requires a full C++ compiler targeted for that CPU. The problem, however, is that compilers are expensive and time-consuming to create. In an attempt to find a better solution, Gosling Java Fundamentals and others worked on a portable, cross-platform language that could produce code that would run on a variety of CPUs under differing environments. This effort ultimately led to the creation of Java.
About the time that the details of Java were being worked out, a second, and ultimately more important, factor emerged that would play a crucial role in the future of Java. This second force was, of course, the World Wide Web. Had the Web not taken shape at about the same time that Java was being implemented, Java might have remained a useful but obscure language for programming consumer electronics. However, with the emergence of the Web, Java was propelled to the forefront of computer language design, because the Web, too, demanded portable programs.
Most programmers learn early in their careers that portable programs are as elusive as they are desirable. While the quest for a way to create efficient, portable (platform-independent) programs is nearly as old as the discipline of programming itself, it had taken a back seat to other, more pressing problems. However, with the advent of the Internet and the Web, the old problem of portability returned with a vengeance. After all, the Internet consists of a diverse, distributed universe populated with many types of computers, operating systems, and CPUs.What was once an irritating but a low-priority problem had become a high-profile necessity.
By 1993 it became obvious to members of the Java design team that the problems of portability frequently encountered when creating code for embedded controllers are also found when attempting to create code for the Internet. This realization caused the focus of Java to switch from consumer electronics to Internet programming. So, while it was the desire for an architecture-neutral programming language that provided the initial spark, it was the Internet that ultimately led to Java’s large-scale success.
How Java Relates to C and C++
Java is directly related to both C and C++. Java inherits its syntax from C. Its object model is adapted from C++. Java’s relationship with C and C++ is important for several reasons. First, many programmers are familiar with the C/C++ syntax. This makes it easy for a C/C++ programmer to learn Java and, conversely, for a Java programmer to learn C/C++.
Second, Java’s designers did not “reinvent the wheel.” Instead, they further refined an
already highly successful programming paradigm. The modern age of programming began with C. It moved to C++, and now to Java. By inheriting and building upon that rich heritage, Java provides a powerful, logically consistent programming environment that takes the best of the past and adds new features required by the online environment. Perhaps most important, because of their similarities, C, C++, and Java define a common, conceptual framework for the professional programmer. Programmers do not face major rifts when switching from one language to another.
One of the central design philosophies of both C and C++ is that the programmer is in charge! Java also inherits this philosophy. Except for those constraints imposed by the Internet environment, Java gives you, the programmer, full control. If you program well, your programs reflect it. If you program poorly, your programs reflect that, too. Put differently, Java is not a language with training wheels. It is a language for professional programmers.
Java has one other attribute in common with C and C++: it was designed, tested, and refined by real, working programmers. It is a language grounded in the needs and experiences of the people who devised it. There is no better way to produce a top-flight professional programming language.
Because of the similarities between Java and C++, especially their support for objectoriented programming, it is tempting to think of Java as simply the “Internet version of C++.” However, to do so would be a mistake. Java has significant practical and philosophical differences. Although Java was influenced by C++, it is not an enhanced version of C++. For example, it is neither upwardly nor downwardly compatible with C++. Of course, the similarities with C++ are significant, and if you are a C++ programmer, you will feel right at home with Java. Another point: Java was not designed to replace C++. Java was designed to solve a certain set of problems. C++ was designed to solve a different set of problems. Both will coexist for many years to come.
How Java Relates to C#
Recently a new language called C# has come on the scene. Created by Microsoft to support its .NET Framework, C# is closely reated to Java. In fact, many of C#’s features were directly adapted from Java. Both Java and C# share the same general C++-style syntax, support distributed programming, and utilize the same object model. There are, of course, differences between Java and C#, but the overall “look and feel” of these languages is very similar. This means that if you already know C#, then learning Java will be especially easy. Conversely, if C# is in your future, then your knowledge of Java will come in handy. Given the similarity between Java and C#, one might naturally ask, “Will C# replace Java?” The answer is No. Java and C# are optimized for two different types of computing environments.
Just as C++ and Java will co-exist for a long time to come, so will C# and Java. 1.2 Java’s Contribution to the Internet
The Internet helped catapult Java to the forefront of programming, and Java, in turn, has had a profound effect on the Internet. The reason for this is quite simple: Java expands the universe of objects that can move about freely in cyberspace. In a network, there are two very broad categories of objects that are transmitted between the server and your personal computer: passive information and dynamic, active programs. For example, when you read your e-mail, you are viewing passive data. Even when you download a program, the program’s code is still only passive data until you execute it. However, a second type of object can be transmitted to your computer: a dynamic, self-executing program. Such a program is an active agent on the client computer, yet it is initiated by the server. For example, a program might be provided by the server to properly display the data that it is sending.
As desirable as dynamic, networked programs are, they also present serious problems in the areas of security and portability. Prior to Java, cyberspace was effectively closed to half of the entities that now live there. As you will see, Java addresses those concerns and, in doing so, has defined a new form of program: the applet.
Java Applets and Applications
Java can be used to create two types of programs: applications and applets. An application is a program that runs on your computer, under the operating system of that computer. An application created by Java is more or less like one created using any other type of computer language, such as Visual Basic or C++. When used to create applications, Java is not much different from any other computer language. Rather, it is Java’s ability to create applets that makes it important. An applet is an application designed to be transmitted over the Internet and executed by a Java-compatible Web browser. Although any computer language can be used to create an application, only Java can be used to create an applet. The reason is that Java solves two of the thorniest problems associated with applets: security and portability. Before continuing, let’s define what these two terms mean relative to the Internet.
Security
As you are almost certainly aware, every time you download a “normal” program, you are risking a viral infection. Prior to Java, most users did not download executable programs frequently, and those that did, scanned them for viruses prior to execution. Even so, most users still worried about the possibility of infecting their systems with a virus or allowing a malicious program to run wild in their systems. (A malicious program might gather private information, such as credit card numbers, bank account balances, and passwords by searching the contents of your computer’s local file system.) Java answers these concerns by providing a firewall between a networked application and your computer.
When using a Java-compatible web browser, it is possible to safely download Java applets without fear of viral infection. The way that Java achieves this is by confining a Java program to the Java execution environment and not allowing it access to other parts of the computer. (You will see how this is accomplished, shortly.) Frankly, the ability to download applets with confidence that no harm will be done to the client computer is the single most important aspect of Java.
Portability
As discussed earlier, many types of computers and operating systems are connected to the Internet. For programs to be dynamically downloaded to all of the various types of platforms, some means of generating portable executable code is needed. As you will soon see, the same mechanism that helps ensure security also helps create portability. Indeed, Java’s solution to these two problems is both elegant and efficient.
外文翻译
Java的基础知识
因特网和万维网的崛起从根本上重塑了计算。仅短短几年前，网络的景观主要是由独立的个人电脑。今天，几乎所有的个人计算机连接到互联网。互联网本身，转化，最初提供一个便捷的方式来共享文件和信息，今天它是一个庞大的，分布式计算宇宙。这些变化已经为快速，因为他们已经深刻的，并在他们之后，他们就产生了一种新的方式来计划：Java的。 Java是互联网的卓越的语言，但它是不止于此。 Java已经彻底改变编程，改变了我们思考的形式和程序的功能的方法。要成为一个专业的程序员今天暗示着编程能力的Java已经成为非常重要的。在这本书的过程中，您将学习如何掌握它所需的技能。该模块的目的是向你介绍Java的，包括它的历史，它的设计理念，它的几个最重要的特点。到目前为止，大约学习一门编程语言中最难的事情是，没有元素是孤立存在的事实。相反，在相互配合的语言工作的组件。这种相互关联是在Java中格外突出。事实上，它是很难讨论的Java的一个方面，而不涉及其他人。为了帮助克服这个问题，该模块提供的多个Java功能，包括Java程序的一般形式，一些基本的控制结构，和运营商的简要概述。它不会进入太多的细节，而是集中在常见的Java程序的一般概念。Java1.1的起源。
计算机语言创新向前驱动由两个因素：改进编程和变化的计算环境的领域中。 Java也不例外。经富遗留从C和C ++继承建筑物，爪哇增加精炼和功能，反映本领域中的编程的当前状态。应对网络环境的兴起，Java提供了简化编程高度分布式架构的特点。
Java是在1991年构思是由詹姆斯·高斯林，帕特里克·诺顿，克里斯·瓦尔特，艾德·弗兰克和麦克谢里丹在Sun Microsystems这种语言最初被称为“橡树”，但更名为“Java”的在1995年出人意料的，对Java的原始动力不上网！相反，主要的动机是，需要一种与平台无关的语言，可用于创建软件要被嵌入在各种消费电子设备，如烤面包机，微波炉，和遥控器。
正如你可能已经猜到，许多不同类型的CPU被用作控制器。麻烦的是，大多数计算机语言被设计为被编译为一个特定的目标。例如，考虑C ++。
虽然可以编译C ++程序几乎任何类型的CPU，这样做需要一个完整的C ++编译器针对该CPU。然而问题是，编译器是昂贵和费时的创建。在试图找到一个更好的解决方案，高斯林的Java基础和他人一起在一个便携式的，跨平台的语言，可以产生不同会在环境上运行的各种CPU的代码。这种努力最终导致建立的Java。
关于Java的细节正在拟定中，第二，最终更重要的时候，出现的因素将在Java的未来起着至关重要的作用。这第二种力量是的，当然，万维网。有网络尚未形成大约在同一时间，Java是正在实施，Java的可能仍然是编程消费电子有用的，但晦涩的语言。然而，随着网络的出现，Java是推进到计算机语言设计的最前沿，因为Web，也要求移植的程序。
大多数程序员学会在其职业生涯早期的便携式程序一样难以捉摸，因为它们是可取的。而追求一种方法来创建高效，可移植（平台无关）方案几乎是一样古老节目本身的学科，它已经退居到其他更紧迫的问题。然而，随着因特网和Web的出现，可移植性的老问题与报复返回。毕竟，互联网由一个多元化，分散居住的宇宙有许多类型的计算机，操作系统，以及CPUs.What曾经是一个刺激，但低优先级的问题已经成为一个备受瞩目的必要性。
到1993年，很明显到便携性的问题创造了嵌入式控制器代码时也发现试图创建代码为上网的时候经常遇到的Java的设计团队的成员。这导致实现了Java的重点从消费电子切换到Internet编程。因此，尽管它是为所提供的初始火花的架构中立编程语言的愿望，这是最终导致Java的大规模成功的互联网。
Java如何涉及到C和C ++
Java的直接关系到C和C ++。 Java的继承了它的语法C.从它的对象模型是改编自C ++。使用C和C ++ Java的关系是有几个原因的重要。首先，许多程序员都熟悉C / C ++的语法。这很容易让一个C / C ++程序员学习Java，相反，对于一个Java程序员学习C / C ++。
Java的设计者并没有“推倒重来。”相反，他们进一步细化了已经非常成功的编程范式。编程的现代时代开始与C.它移动到C ++，现在到Java。通过继承并在这丰富的文物建筑，Java提供了一个强大的，在逻辑上是一致的编程环境，以最佳的过去，并增加了网络环境所需要的新功能。也许最重要的，因为他们的相似之处，C，C ++和Java的，定义为专业的程序员共同的，概念框架。从一种语言到另一种切换时的程序员不面临着重大分歧。
其中C和C ++的核心设计理念是程序员负责！ Java也继承了这一理念。除了通过互联网环境施加的这些限制，Java的给你，程序员，完全控制。如果你的程序顺利，你的程序反映它。如果你的程序不好，你的计划反映出这一点。换句话说，Java是不是与训练车轮的语言。这是适合专业程序员的语言。
Java有一个共同点，其他的属性与C和C ++：它的设计，测试，并通过真实的，工作的程序员细化。它是在需要和谁设计它的人的经验，接地的语言。有没有更好的方式来产生第一流的专业编程语言。
由于Java和C ++，尤其是他们对面向对象编程的支持之间的相似性，很容易让人想到Java作为简单的“C ++的互联网版本。”不过，这样做将是一个错误。 Java有显著实践和哲学的差异。尽管Java是受到C ++，它不是C ++的增强版。例如，它既不向上也不使用C ++向下兼容。当然，C ++是显著的，如果你是一个C ++程序员，你会感到宾至如归与Java的相似之处。还有一点：Java是不是设计来取代C ++。 Java被设计来解决一组特定的问题。 C ++的目的是要解决不同的问题。双方将共存很多年的到来。
Java如何涉及到C＃
最近，一个新的语言称为C＃已经来到现场。创建由微软支持其.NET框架，C＃是密切reated到Java。事实上，许多C＃的特点是直接改编自爪哇。 Java和C＃的份额大致相同的C ++ - 风格的语法，支持分布式编程，并利用相同的对象模型。有，当然，Java和C＃之间的差异，但总的“外观和感觉”这些语言是非常相似的。这意味着，如果你已经知道C＃，然后学习Java将是特别容易。相反，如果C＃是在你的未来，那么你的Java知识就派上用场了。鉴于Java和C＃之间的相似性，人们自然会问，“请问C＃取代Java？”答案是号Java和C＃是两种不同类型的计算环境的优化。
正如C ++和Java共存很长一段时间来，所以将C＃和Java。 1.2 Java的贡献上网互联网帮助弹射器的Java编程的最前沿，和Java，反过来，已在互联网上产生深远的影响。这样做的原因很简单：Java的扩展，可以在网络空间自由走动对象的宇宙。在网络中，有两个非常广阔对象的类别，在服务器和个人电脑之间传输：被动的信息和动态，活动程序。例如，当你阅读电子邮件，您正在查看被动数据。甚至当你下载一个程序，该程序的代码仍然是被动的唯一数据，直到你执行它。然而，第二类型的对象可以被发送到计算机：一个动态的，自动执行的程序。这样的程序是在客户端计算机上的活性剂，但它是由服务器发起的。例如，一个程序可能会被提供该服务器能够正确显示它正在发送数据。
作为理想的动态，网络程序，它们也是在安全性和便携性方面存在严重问题。在此之前的Java，网络空间被有效封闭半，现在生活在那里的实体。正如你所看到的，Java的解决了这些问题，并在此过程中，已定义的节目的新形式：小程序。
Java applet和应用
Java可以被用来创建两种方案：应用程序和applets。一个应用程序是运行在您的计算机上，在那台电脑的操作系统的程序。在Java创建的应用程序或多或少像一个使用的任何其他类型的计算机语言，创建如Visual Basic或C ++。当用于创建应用程序，Java是不是从任何其他计算机语言太大的不同。相反，它是Java的创建小应用程序，使得它重要的能力。一个applet是设计成可通过互联网传送和由Java兼容的Web浏览器上执行的应用。虽然任何计算机语言可以用来创建应用程序，只可以用Java创建applet。其原因是，Java的解决了两个与小程序有关的最棘手的问题：安全性和便携性。在继续之前，让我们来定义什么这两个词的意思是相对于上网。
安全性
当你几乎肯定是知道的，每次你下载一个“正常”的程序时，你冒着被病毒感染。在此之前的Java，大多数用户没有下载可执行程序频繁，而那些确实，在执行之前扫描他们的病毒。即便如此，大多数用户还是担心自己感染系统的病毒或允许恶意程序在其系统上运行野生的可能性。 （恶意程序可能会收集私人信息，如信用卡号码，银行账户余额，并通过搜索计算机的本地文件系统的内容，密码）。通过联网的应用程序和计算机之间提供防火墙的Java回答这些问题。
当使用一个Java兼容的web浏览器，能够安全地下载Java小应用程序，而不必担心病毒感染。了Java实现此的方式是通过限制Java程序的Java执行环境，不允许它访问计算机的其他部分。 （你会看到这是如何实现的，很快。）坦率地说，下载小程序有信心的能力，没有损害将完成到客户端计算机是Java的一个最重要的方面。
可移植性
如前面所讨论的，许多类型的计算机和操作系统的连接到互联网。对于方案被动态地下载到所有不同类型的平台的，产生可移植可执行代码的一些手段是必要的。正如你很快就会看到，同样的机制，有助于确保安全性也有助于创造的便携性。事实上，Java的解决了这两大问题，是既优雅又高效。
也是在安全性和便携性方面存在严重问题。在此之前的Java，网络空间被有效封闭半，现在生活在那里的实体。正如你所看到的，Java的解决了这些问题，并在此过程中，已定义的节目的新形式：小程序。
Java applet和应用
Java可以被用来创建两种方案：应用程序和applets。一个应用程序是运行在您的计算机上，在那台电脑的操作系统的程序。在Java创建的应用程序或多或少像一个使用的任何其他类型的计算机语言，创建如Visual Basic或C ++。当用于创建应用程序，Java是不是从任何其他计算机语言太大的不同。相反，它是Java的创建小应用程序，使得它重要的能力。一个applet是设计成可通过互联网传送和由Java兼容的Web浏览器上执行的应用。虽然任何计算机语言可以用来创建应用程序，只可以用Java创建applet。其原因是，Java的解决了两个与小程序有关的最棘手的问题：安全性和便携性。在继续之前，让我们来定义什么这两个词的意思是相对于上网。
安全性
当你几乎肯定是知道的，每次你下载一个“正常”的程序时，你冒着被病毒感染。在此之前的Java，大多数用户没有下载可执行程序频繁，而那些确实，在执行之前扫描他们的病毒。即便如此，大多数用户还是担心自己感染系统的病毒或允许恶意程序在其系统上运行野生的可能性。 （恶意程序可能会收集私人信息，如信用卡号码，银行账户余额，并通过搜索计算机的本地文件系统的内容，密码）。通过联网的应用程序和计算机之间提供防火墙的Java回答这些问题。
当使用一个Java兼容的web浏览器，能够安全地下载Java小应用程序，而不必担心病毒感染。了Java实现此的方式是通过限制Java程序的Java执行环境，不允许它访问计算机的其他部分。 （你会看到这是如何实现的，很快。）坦率地说，下载小程序有信心的能力，没有损害将完成到客户端计算机是Java的一个最重要的方面。
可移植性
如前面所讨论的，许多类型的计算机和操作系统的连接到互联网。对于方案被动态地下载到所有不同类型的平台的，产生可移植可执行代码的一些手段是必要的。正如你很快就会看到，同样的机制，有助于确保安全性也有助于创造的便携性。事实上，Java的解决了这两大问题，是既优雅又高效。