Greenfoot快速入门的方法_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
Greenfoot快速入门的方法
上传于||暂无简介
阅读已结束，如果下载本文需要使用0下载券
想免费下载更多文档？
定制HR最喜欢的简历
你可能喜欢当前位置： >
> Greenfoot(java开发环境)
v3.0.0 英文安装免费版
Greenfoot(java开发环境)
v3.0.0 英文安装免费版
Greenfoot下载
软件大小：186MB
软件语言：英文软件
软件类型：
软件授权：免费软件
更新时间：
软件类别：开发辅助
软件官网：
应用平台：
网友评分：
软件介绍人气软件下载地址相关文章
asp.net mvc4.0 安装包，安装前请确保vs2010已升级为sp1版本正则表达式测试器允许你测试和分析正则表达式，方便测试正则表达式的朋友非常好的vc插件，自动识别各种关键字，系统函数，成员变量，自动给出输入提示，自动更正大小写错误，自动标示错误，等等啦……支持VC++ 6, VC++ 5 andVC 3!正则表达式测试器允许你测试和分析正则表达式，方便测试正则表达式的朋友压缩css和js是我们工作中经常要处理的一件事,这里介绍的是一款基于YUICompressor,淘宝封装的css和js压缩工具TBCompressor.
TBCompressor的安装很简单,点击install.cmd本软件是VS2010 C++ 智能提示插件，Visual Assist 可以在目前的及历史版本的Visual Studio中很好的工作： 支持的VS版本：VS2012、VS2010、VS2008、VS2005、VS2003、VS2002将任何BAT、CMD批处理脚本编译为EXE文件！此完美解密套装版包含编译器（Compiler，v2.0.7.0）和反编译器（DeCompiler，v1.0.3.6）。
很久以前接触过PCMag某位大虾写的BAT2
.Net Framework 2.0下正则表达式的行为，所以，我向你介绍一个.Net下的工具Regex Tester。首先你确保已经安装了.Net Framework 2.0，然后下载Regex Tester。这是个绿色软ADT 是 Eclipse 开发 Android 应用程序的插件压缩包内包含Adobe Dreamweaver CS3，Adobe Flash CS3，Adobe Fireworks CS3。
安装说明：先卸载你原来的版本，然后全新安装此版即可。
Greenfoot(java开发环境)
v3.0.0 英文安装免费版
CopyRight &
JB51.Net , All Rights Reserved【图文】ch11_greenfoot游戏设计_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
评价文档：
ch11_greenfoot游戏设计
上传于||暂无简介
大小：551.00KB
登录百度文库，专享文档复制特权，财富值每天免费拿！
你可能喜欢Greenfoot&程序员手册
Greenfoot&程序员手册
　　1、导言
　　Greenfoot 是为初学者设计的工具软件，用以感受面向对象编程的魅力。它支持基于Javatm 编程语言的图形化应用程序开发。想了解 Greenfoot 教程、视频和快速入门指南，请查看 " Getting Started " .
　　这本手册介绍了Greenfoot编程。它从一开始，讨论我们如何创建一个新的脚本，然后介绍怎样创造世界和角色， 等等。
　　这也许不是你获得Greenfoot编程经验的步骤。事实上，人们起初学习Greenfoot更普遍的方法是修改现有的脚本。在这种情况下， 你将使用已有的脚本、世界、一种或多种角色类型。
　　自由、迅速地跳到手册中你喜欢的部分并开始阅读。例如，你对以某种方式生成角色图像感兴趣，或者喜欢处理对象的交互。这本手册的各个部分被设计成相互独立的环节―没有必要按顺序读完所有的内容。
　　无论何时，参考实例都是非常有用的。我们将使用 'wombats（袋熊）'， 'ants（蚂蚁）'， 'balloons（气球）' 和 'lunarlander（月球登陆者）' 脚本作为例子。以上这些脚本都包含在标准的Greenfoot发行版中。你可以在 'scenarios' 文件夹中找到它们。
　　Have fun！
　　2、创建一个新的设想
　　如果你想拥有属于自己的程序，第一步是创建你自己的脚本。
　　这很简单：在 'Scenario' 菜单中选择New，然后为你的脚本设置保存路径和名字。 Greenfoot 会创建一个文件夹，里面包含了和你的脚本有关的所有文件。
　　随后这个脚本会被打开，你将看见一个跟左边类似的窗口。在那上面，有 'World' classesand 和'Actor' classes 关系图。
　　'World' 和 'Actor' 都是 abstract classe（抽象类） ―― 就是说：你不能为它们创建对象。
　　当前没有world对象，因为我们没有完整的world类。
　　这样一来，即使我们现在有一个actor对象，我们也没有地方可以放置，因为我们没有创造一个世界。
　　为了实现我们的设想， 我们需要创建 World 和 Actor 的子类（特殊类）。也就是说： 我们要开始定义自己的世界，然后再定义一个或多个我们世界的成员。
　　这将在下一部分进行介绍。
　　在 Grenfoot 全球站点，有一系列可用的 视频教程 ，向我们展示了如何创建和设置一个新脚本。
　　3、使用API
　　当使用Greenfoot进行编程的时候，了解标准 Greenfoot 类的可用方法是必要的。这些可用方法称为 Greenfoot API （即 "Application Programming Interface"），可以在 Greenfoot 全球站点 进行查看。
　　你可以在右边的Help菜单中选择 'Greenfoot Class Documentation' 选项，在浏览器打开 API 帮助文档，或者在World 或 Actor 类上双击。API帮助文档是和Greenfoot绑定在一起的， 因此你不需要联网就可以查看它。
　　Greenfoot 提供了5个你需要了解的类。分别是： World， Actor， Greenfoot， GreenfootImage 和 MouseInfo.
　　World 类和 Actor 类作为实现我们自己的世界及其成员的 超类――我们已经在关系图中见过了它们。
　　'GreenfootImage' 是一个在使用世界及其成员时为我们提供图形及图形绘制方法的类。
　　'Greenfoot' 类给我们提供了使用Greenfoot自身框架的入口，例如暂停执行或调整速度。
　　'MouseInfo' 则是一个提供鼠标输入信息的类，例如鼠标单击的坐标以及什么角色被点击。
　　所有这些类会在后面的内容中详细地介绍。当你使用Greenfoot进行设计的时候， 打开API对你来说会是一个好的习惯， 无论是将它打印出来还是在web浏览器中查看。
　　4、创造一个世界
　　创建一个新的世界，在 World 类的弹出菜单中选择 'New subclass……' （如右图）。
　　为你的新世界命名并点击OK之后，你就会在关系图中看到这个新的世界。这个新世界具有可编辑的逻辑结构 .
　　现在编辑你的脚本， 然后你会发现这个新的世界会自动地在主视窗中显示出来。这是Greenfoot内置的一个特性：当一个正确的 world 类存在并经过了编译，Greenfoot 就会创建一个world对象并且将它显示在主视窗中。
　　理论上，你可以在同一个Greenfoot脚本中拥有多个 world 子类。但是哪一个世界会被自动地创建却不能完全确定。你可以自己用 world 的构造方法创建一个世界，但实际上，一个脚本中我们通常只创建一个 world 子类。
　　世界的大小和分辨率
　　让我们进一步看看新的 world 子类中的代码。默认的结构如下所示：
import greenfoot.*;& // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)public class MyWorld& extends World{&&& /**&&&& * Constructor for objects of class MyWorld.&&&& * &&&& */&&& public MyWorld()&&& {&&& &&&&&&& // Create a new world with 20x20 cells with a cell size of 10x10 pixels.&&&&&&& super(20, 20, 10); &&& }}
　　我们要做的第一件是确定世界的大小和格子的大小。 而世界的种类又分为两种情况，一种是：每个角色对象占据一个大网格 （即： 一个网格要足够容纳一个完整的角色）；另一种是：这些角色跨越多个小网格。
　　你大概已经见过这两种情况了。例如， 'wombats' 是第一类，而 'ants' 是第二类。（ wombats 脚本和 ants 脚本被作为范例与Greenfoot一同发行。如果你没有看过他们， 并且不太明白我现在讨论的东西， 那现在打开它们看看会对你有所帮助）
　　通过 super 语句，我们可以在父类的构造方法中指定世界的大小和网格的大小。例如，我们把它改成：
super(10, 8, 60);
　　这样，我们将会得到一个宽10格、高8格、每个网格尺寸为60x60像素的一个世界。父类 World 构造方法的形参如下
public World(int worldWidth, int worldHeight, int cellSize)
　　所有角色在世界中的定位都是基于网格，你不能把角色放在网格之间 （尽管一个角色图像可能比网格大，那也只是覆盖多个网格）。
　　大―小网格间的权衡
　　当为世界的单元决定大小的时候，你就要在平滑的运动和简便地探测两者间作出权衡。
　　将角色限制在网格中的同时也会造成粗糙的运动。例如 wombats 脚本，用的60像素的网格，于是，每当袋熊向前移动一步，它们的图像就会在屏幕上移动60像素。另一方面， 在各种角色能被网格完全容纳的世界中， 一种物体探测同一个位置中的其它物体是很简单的――我们不需要跨图像去检测，而只需查看同一个网格中是否存在其它物体。当然，发现邻近网格中的物体也很容易。
　　在后面的部分中我们会进行更详细的讨论，见 'Detecting other objects (collisions)'
　　如果你需要生成平滑的运动，你就要使用细小的网格。例如 'ants' 脚本， 用的1像素的网格，使蚂蚁可以小步地移动。这种方式同样适合大体积的对象。例如 'lunarlander' 脚本，在1像素网格的世界中用了一个大体积的角色（火箭）。 由于位置是一个像素接一个像素地转换，所以角色可以作非常平滑的运动。
　　世界的背景
　　大多数时候，我们想为世界设置一个背景。这相对比较容易。
　　首先，你需要提供一张合适的背景图片。Greenfoot的安装文件里自带了许多的背景图片。你可以在创建类的时候选择其中一张作为世界的背景，或者在类的弹出菜单中选择 'Set image……' ，然后在图片库中选择你喜欢的。
　　在Greenfoot全球站点上有更多可用的背景图片 Greenfoot Image Collection. 想使用来自那上面的图片或是你自己制作的图片，你需要把它们放进你的脚本文件夹中的 'images' 文件夹内。只有这些图像文件在那，你的脚本才可以使用它们。然后你就可以在打开'Set image' 或 'New subclass' 对话框，从 'Scenario images' 列表中选择你想要的。
　　你也可以在Java代码里设置背景图片，方法如下：
setBackground("myImage.jpg");
　　"myImage.jpg" 这个参数的位置要使用正确的图片名。假设我们把名为 "sand.jpg" 的图片放进我们脚本的 'images' 文件夹里，那么我们就可以在构造方法中这样写：
&&& public MyWorld() &&& {&&&&&&& super(20, 20, 10);&&&&&&& setBackground("sand.jpg");&&& }
　　这个图片就会像砌砖瓦一样铺满这个世界。想得到连续的背景，你就要选用能准确匹配世界边缘的图片。或者选用一张足够大的图片来覆盖整个世界。
　　如果你想用代码来给背景上色，来代替图像文件，也是很简单的事情。世界一直有背景对象，默认情况下，它跟世界大小相同并且完全透明。我们可以调出背景对象，并给它附加一些图像绘制的命令，例如：
&&& GreenfootImage background = getBackground();&&& background.setColor(Color.BLUE);&&& background.fill();
　　整个背景将会充满蓝色。
　　还可以将上面这两种方法结合起来：先导入一张图片， 然后进行一些处理， 最后用这张修改过的图片作为世界的背景：
&&& GreenfootImage background = new GreenfootImage("water.png");&&& background.drawString("WaterWorld", 20, 20);&&& setBackground(background);
　　背景图像在默认的 world 构造方法中仅仅设定了一次，然而在脚本运行的过程中，你仍然可以动态地改变背景。
　　显示栅栏在使用大格世界的的时候，有时你想要显示出网格的轮廓。'wombats'脚本就是这样――你可以看见涂色后的网格边框。
　　在Greenfoot中，这样做没有什么特别的作用，仅仅是为了看见网格。袋熊世界的网格边长60像素，背景图片的尺寸是60x60像素（符合单元格的大小）， 其左边缘和上边缘有黯淡的边线。The effect of this is a visible grid when the tiles are used to fill the world background.
　　通过构造方法，可以使用代码在绘制背景图像上绘制栅栏。例如：
&&& private static final Color OCEAN_BLUE = new Color(75, 75, 255);&&& private static final int ENV_SIZE = 12;& // environment size in numer of cells&&& private static final int CELL_SIZE = 40; // cell size in pixels&&& ...&&& private void drawBackground()&&& {&&&&&&& GreenfootImage bg = getBackground();&&&&&&& bg.setColor(OCEAN_BLUE);&&&&&&& bg.fill();&&&&&&& bg.setColor(Color.BLACK);&&&&&&& for(int i = 0; i & ENV_SIZE; i++) {&&&&&&&&&&& bg.drawLine(i * CELL_SIZE, 0, i * CELL_SIZE, ENV_SIZE * CELL_SIZE);&&&&&&&&&&& bg.drawLine(0, i * CELL_SIZE, ENV_SIZE * CELL_SIZE, i * CELL_SIZE);&&&&&&& }&& }
　　5、创造新的角色
　　这一部分讨论角色类的一些特点以及在编写它们的时候需要注意些什么。
　　所有我们想在脚本中使用的角色类都是内置 'Actor' 类的子类。我们可以从 Actor 类的右键菜单中选择 'New subclass……' 来创建新的角色类。
　　接下来的对话框让我们为这个新类指定名字和图片。这个名字必须是合法的Java类名（即： 它只能包含字母和数字）。 这个图片将会是所有这个类的对象的默认形象。
　　类的形象
　　每个类都有一张相关的图片作为其所有对象的默认图片。每个对象都可以根据需要改变形象， 因此，类的特殊对象可以是各式各样的。这在以后的部分会更深入的讨论，见 'Dealing with images'. 如果对象没有设定确切的图片，他们将会使用类的图片。
　　对话框中的图片选择器展示了两组图片： 项目图片和库图片。库图片被包含在了Greenfoot的安装文件中，项目文件被存放在你的脚本（项目）文件夹中的 'images' 文件夹中。如果你想使用自己收集的图片，有两个办法：
　　●& 你可以把你的图片复制到脚本中的 'images' 文件夹。随后它就会出现在对话框中； 或者&&& ●& 你可以使用对话框中的 'Browse for more images' 按钮选择你收集的图片。这张图片随后会自动复制到脚本中的 image 文件夹。
　　初始化
　　和大多数Java项目一样，通常都是把对象的初始化放在构造方法里。然而，有些初始化任务不能在这里完成。原因是，在对象被创建的过程中，他尚未被放入世界。 事件执行的顺序是：
　　1、创建对象&&& 2、将对象导入世界
　　在第一步中，对象执行构造方法。由于此刻对象没有存在于世界中，像getWorld（）， getX（） 和 getY（） 这样的方法不能在构造方法中调用 （当你没有在世界中，你就没有相应的位置）。
　　因此，如果我们想实现一些方式（比如在世界中创建其它对象，或者根据附近的其它对象变换图片） 作为初始化方法的组成部分，那就需要世界的入口，但是这个入口是不能在构造方法中实现的。 不过， 我们有第二个初始化方法，叫做 'addedToWorld' .每个角色类都从父类 'Actor' 继承了这个方法。
　　示例：
public void addedToWorld(World world)
　　public void addedToWorld（World world）当角色被添加的到世界中的时候，这个方法会被自动地调用。因此在对象被添加的时候，如果我们有任务要执行，我们需要做的就是在类里定义一个 'addedToWorld' 方法，并且使用同样的方法名，然后在里边写上你的代码。
　　例如：
&&& public class Rabbit extends Actor&&& {&&&&&&& private GreenfootImage normalI&&&&&&& private GreenfootImage scaredI&&&&&&& public Rabbit()&&&&&&& {&&&&&&&&&&& normalImage = new GreenfootImage("rabbit-normal.png");&&&&&&&&&&& scaredImage = new GreenfootImage("rabbit-scared.png");&&&&&&& }&&&&&&& public void addedToWorld(World world)&&&&&&& {&&&&&&&&&&& if(isNextToFox()) {&&&&&&&&&&&&&&& setImage(scaredImage);&&&&&&&&&&& }&&&&&&&&&&&& else {&&&&&&&&&&&&&&& setImage(normalImage);&&&&&&&&&&& }&&&&&&& }&&&&&&& private boolean isNextToFox()&&&&&&& {&&&&&&&&&&& ... // calls getWorld() to check neighbours in world&&&&&&& }&&& }
　　这个例子表示的是： 将一只兔子放进世界，当它远离狐狸的时候看起来很正常，但是当它靠近狐狸的时候就变得很惊恐。实现这种变化，我们用了两张图片（"rabbit-normal.png" 和 "rabbit-scared.png"）。 我们可以在兔子的构造方法中加载这些图片，但是我们不能将它们显示出来， 因为这要牵涉到“检测世界”，在构造方法执行的过程中要做到这些是不是件轻松的事情。
　　当你把一个对象放进世界， 会依次执行一下步骤：
　　1、创建对象 （执行构造方法）。&&& 2、将对象放入世界。&&& 3、调用对象的 setLocation 方法获得新的位置坐标。&&& 4、调用对象的 addedToWorld 方法。
　　在我们上面这个例子中， 在 addedToWorld 方法执行后，兔子就出现在了世界中并有了一个位置。这样我们就可以调用我们的 isNextToFox（） 方法 （其中可能会使用到世界和兔子的方位）。
　　每当对象的方位被改变后，setLocation 方法都会被调用，而 addedToWorld 方法仅仅被调用一次。
　　'lunarlander' 脚本的 'Lander' 类（来自Greenfoot 示例脚本） 展示了使用这个方法的另一个例子。
　　6、让他们动起来
　　每当你点击界面上的 'Act' 按钮，世界中每个对象的 'act'方法就会被调用。'act' 方法的形式如下：
public void act()
　　每个活动的类 （想让它做什么事情的时候） 都应该继承这个方法。
　　点击 'Run' 按钮的效果其实就是快速重复点击 'Act' 按钮。换句话说，只要脚本在运行，我们的 'act' 方法就会被一次接一次地重复调用。
　　要让对象在屏幕上移动，修改对象的属性就行了。每个角色的其中3项属性，当你改变它们的时候，在屏幕上的变化会非常明显（自动且即时）。 它们是：
　　●& 方位 （由x，y坐标确定）
　　●& 旋转度
　　●& 图像
　　如果改变其中任意一个属性，角色在屏幕上的方式就会改变。Actor 类具有改变这些属性的方法。
　　改变方位
　　最先观察到的是方位的改变。看看下面的代码
&&& public void act()&&& {&&&&&&& int x = getX();&&&&&&& int y = getY();&&&&&&& setLocation(x + 1, y);&&& }
　　这一代码片段的作用就是让角色向右移动一个格子。它通过获得角色的当前坐标， 然后为角色设置一个新的坐标x-坐标。
　　我们可以把这段代码简化一下
&&& public void act()&&& {&&&&&&& setLocation(getX() + 1, getY());&&& }
　　一旦我们的角色抵达世界的边缘，它会继续试图向外移动，但是Greenfoot不会让它出去。想改变这种情况，我们需要增加代码，来检测我们是否可以朝那个方向前进（在向那运动之前）。 袋熊脚本就是这样的。
　　世界的位置坐标是单元格的索引。它们不会超越世界的尺寸。 （0，0） 点在世界的左上角，向右x值增加，向左y值增加。
　　改变旋转的方向
　　通过与“改变方位”类似的方法， 我们可以改变对象图像的旋转度。请看下面的代码：
&&& public void act()&&& {&&&&&&& int rot = getRotation() + 1;&&&&&&& if(rot == 360) {&&&&&&&&&&& rot = 0;&&&&&&& }&&&&&&& setRotation(rot);&&& }
　　用这个方法得到角色当前的角度，然后对其进行运算。它就沿顺时针方向慢慢地转动。
　　旋转度的有效范围是[0―359]，并且角度沿顺时针方向增加。 因此，在上面的代码中，我们检查rot是否达到360° （即： 离开有效范围），是就把它归0.
　　改变形象
　　最后一个能被自动反映的角色属性是角色的图像。图像改变后会立即表现在屏幕上。看看这段代码：
&&& public void act()&&& {&&&&&&& if(hasEaten()) {&&&&&&&&&&& setImage("happy.jpg");&&&&&&& }&&&&&&& else {&&&&&&&&&&& setImage("sad.jpg");&&&&&&& }&&& }
　　这段代码假定了我们的代码中有一个 hasEaten（） 方法，然后设定相应的图片。有两种 setImage 方法： 一种接受一个图片文件名作为参数，另一种接受一个 GreenfootImage 类型的对象作为参数。
　　通常，将图片文件加载到一个 GreenfootImage 对象中是一个好主意，如果你需要多次设置图像，就可以重复使用同样的图像对象。比如，想在 act 方法中替代重复调用的下面这种方法：
setImage("happy.jpg");
　　你可以初始化这个图片的一个实例：
private GreenfootImage happyImage = new GreenfootImage("happy.jpg");
　　然后用这个对象设置图像：
setImage(happyImage);
　　更多关于处理图像的信息在后面的部分，见 'Dealing with images' .
　　有一系列关于移动角色的可用 视频教程 在 Greenfoot 全球站点。
　　7、随机行为
　　在Greenfoot脚本中，随机行为是基于随机数字的。
　　在 Greenfoot 中生成随机数字是相当容易的。Greenfoot 有一个叫做 'Greenfoot' 的内置类，是框架的一个部分（see The Greenfoot class， below）。 这个类有一个叫做 getRandomNumber 的方法。它的形式如下：
public int getRandomNumber(int limit)
　　在我们的代码中，如果需要得到一个随机数字，我们可以随时调用这个方法：
int myNumber = Greenfoot.getRandomNumber(10);
　　在这个例子中，我们将会得到一个范围 [0……9] 的数字。即： 这个数字总是在 0 （包括） 和你指定的参数limit（不包括）之间。想了解详细内容，请在 Greenfoot API 中查看Greenfoot 类的描述。
　　一旦你得到随机数字，用它们作为随机行为只需一小步。例如：
&&& if(Greenfoot.getRandomNumber(2) == 0) {&& // 50% chance&&&&&&& turnLeft();&&& }&&& else {&&&&&&& turnRight();&&& }
　　更多的示例，见 'wombats2' 脚本中的 'Wombat' 类，或者是 'ants' 脚本中的 'Ant' 类。
　　8、处理图像
　　Greenfoot 提供各种不同的方法来令对象获得图像。
　　对象可以通过下面这3种方法中之一来获得图像，也可以把它们结合起来使用：
　　1、使用类的图像&&& 2、从磁盘上加载图片文件&&& 3、控制代码绘制图像
　　所有3种方法都被蚂蚁脚本用上了，它包含在Greenfoot的发行版中。如果你想学习怎么绘制图像，这个脚本会对你非常有帮助。在下面的内容中，我们会多次提到到这个脚本。
　　我们会一次讨论所有3种方法。 在 Greenfoot 全球站点上也有可用的 视频教程 展示了如何用这些方法制作背景图像。
　　使用类的图像
　　每个类都有一张相关图片。它会在创建类的时候被指定，但此后可以用类右键菜单中的 'Set Image……' 功能替换。
　　想让对象使用类的图片，我们没有什么特别的事情需要做。如果我们不需要特殊的图像处理代码。类的图片就会被用来显示对象。
　　在蚂蚁项目中，蚁窝就用到了这种技巧。这个类指定了统一的图像。
　　使用图片文件
　　通过使用 Actor' 的'setImage（……）' 方法，我们可以轻松地为个别对象修改形象。蚂蚁脚本就使用了这种方法。当蚂蚁发现了食物，它的 takeFood（） 方法就会被执行，这个方法中包含了下面这条语句：
setImage("ant-with-food.gif");
　　当蚂蚁放下了食物 （使用 dropFood（） 方法）， 它执行了另一条语句：
setImage("ant.gif");
　　这样，每个蚂蚁对象的形象就可以动态地改变。
　　使用 'setImage' 方法时，会从磁盘加载一张图片，参数用来指定文件名，并且这个文件必须存放到项目的 'images' 文件夹中。
　　如果对象的形象频繁地改变，或者需要迅速地变换，那么从磁盘上加载图片并把它存进 GreenfootImage 类型的对象中是最优的方法。下面的代码片段阐述了这种方式：
&&& public class Ant extends Actor&&& {&&&&&&& private GreenfootImage foodI&&&&&&& private GreenfootImage noFoodI&&&&&&& public Ant()&&&&&&& {&&&&&&&&&&& foodImage = new GreenfootImage("ant-with-food.gif");&&&&&&&&&&& noFoodImage = new GreenfootImage("ant.gif");&&&&&&& }&&&&&&& private boolean takeFood()&&&&&&& {&&&&&&&&&&& ... &&&&&&&&&&& setImage(foodImage);&&&&&&& }&&&&&&& private boolean dropFood()&&&&&&& {&&&&&&&&&&& ... &&&&&&&&&&& setImage(noFoodImage);&&&&&&& }&&& }
　　这个示例描述了这样一种设置图像的方法： setImage 也可以使用 GreenfootImage 对象作为参数代替文件名。 GreenfootImage 对象可以用文件名作为其构造方法的参数，生成的对象可以被重复地使用。
　　这种方法保存了资源并且执行迅速，非常适合于图像频繁改动的情况。
　　Greenfoot中区分温江名的大小写。例如， "image.png"， "Image.png" 和 "image.PNG" 都是不同。你必须使用正确的名称，否则 Greenfoot 找不到相应的图片。
　　生成图像
　　通过代码可以在运行的时候生成图像。当图像有很多细节的变动时这种方法非常有用，而且绘制起来也很简单。蚂蚁脚本的 Food 类用这种方法来显示一堆中有多少数量的食物， 而 Pheromone（信息素） 类用它实现强度变化。
　　创建图像对象
　　生成图像之前，你需要有一个 GrenfootImage 对象。可以用一张空图像，一张图片文件，或是类的默认图片。 要创建一张空白图像，你需要将你所要的图像的宽度和高度传到 GreenfootImage 构造方法中。这张图像是完全透明的。
&&& GreenfootImage image = new GreenfootImage(60, 50);&&& //Creates an image 60 pixels wide and 50 pixels high
　　如果你正在使用一张已经存在的 GreenfootImage 类型图像， 你可能需要创建一个副本来进行绘制，这样原图就能得到保护。
GreenfootImage image_copy = new GreenfootImage(image);
　　绘制图像
　　一旦你有了一张可以绘制的图像，无论它是空白的还是包含内容的，你都可以使用 GreenfootImage 类的一些方法来添加图像。GreenfootImage 类提供的方法可以让你：
　　●& 绘制直线， 矩形， 椭圆 （包括圆）和多边形&&& ●& 绘制实心的矩形， 椭圆和多边形&&& ●& 设置单个像素的色彩&&& ●& 为整张图像填充统一的色彩&&& ●& 在图像上写一串文字&&& ●& 把另一张 GreenfootImage 图像复制到一张图像上&&& ●& 缩放，旋转和映射图像&&& ●& 设置图像的透明度
　　添加色彩
　　在使用任一绘制方法之前，你需要告诉图像你想为它添加什么颜色。这需要调用 GreenfootImage 对象的 setColor（） 方法。这个方法从 Java 库取得一个Color 对象。获得 Color 对象最快的方法是使用 Color 类中预先定义的常量，比如 Color.BLACK.其它可用的颜色还有：white， gray， red， green， blue， yellow and orange. 查看 the Java API documentation of the Color class了解详细的颜色表以及取得颜色对象的其它方法。
　　由于我们使用了 Java 类库的一个类，所以必须告诉编译器去哪找它。这就要在Java文件的顶部添加一条 'import' 语句。现在已经有了一条导入 Greenfoot 类的语句。我们另起一行导入 Color 类，完整的名字是 java.awt.Color.
&&& import greenfoot.*;& // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)&&& import java.awt.C
　　之后我们就可以用生成图像的相应方法，设置我们喜欢的颜色：
image.setColor(Color.BLACK);
　　画一条线
　　可以用 drawLine（） 方法在图像画一条直线。它需要4个参数，前两个参数―（x，y）坐标―指定线段的起点，最后两个―（x，y）坐标―指定线段的终点。一张图像的起始坐标是左上角的 （0，0），并且以像素为单位。这类似于将角色放入世界， 只是世界可以使用大于一个像素的格子，而 GreenfootImage 总是以像素为单位 .
　　下面的代码会在图像顶部画了一条长15像素的线条
image.drawLine(0,0, 14,0);
　　这条线段起于图像左上的 （0，0），结束于 （14，0）。第15个像素的 x 坐标 是14，而1个像素的坐标是0. 如果你想画一条穿越整个图像顶端的线段，可以使用以下代码：
image.drawLine(0,0, image.getWidth()-1,0);
　　下面这段代码将会画一条从图像左上角的点 （0，0） 到中部右方的点 （59，25） （一张60x50像素的图片）：
image.drawLine(0,0,59,25);
　　绘制圆，矩形或其他形状矩形
　　可以用 drawRect 方法绘制。 这个方法也需要4个参数： 矩形左上角的坐标 （x，y） 以及它的宽度和高度。下面这段代码将会从图像的左上角开始，绘制一个从像素点（0，0）开始宽增加60像素高增加30像素的矩形（61x31）：
image.drawRect(0,0,60,30);
　　这个矩形覆盖了一个宽 width + 1 像素，高 height + 1 像素的区域。意思是如果你想绘制一个环绕图像边缘的矩形，使用下面的代码：
image.drawRect(0,0,image.getWidth()-1,image.getHeight()-1);
　　圆和椭圆可以通过调用drawOval方法进行绘制，指定椭圆写入区域左上角的坐标，以及宽度增量和高度增量。与矩形不同的是， 这个指定的坐标没有在绘制的线条上： 圆的左边在 x 坐标上，顶部在 y 坐标上。
　　要想画一个宽21像素、高11像素、起点在 （5，10） 的圆，你应该使用下面的参数：
image.drawOval(5,10,20,10);
　　像矩形一样，椭圆覆盖了一个宽 width + 1像素，高 height + 1 像素的区域。
　　你可以用 drawPolygon 方法绘制更多结构复杂的多边形，它们需要一个x坐标数组，一个y坐标数组和顶点的数量。这些坐标点按照数组顺序依次进行链接，然后从终点向起点闭合（闭合多边形）。
　　这3种方法都有相应的 'fill' 版本，用来绘制实心图形，而不仅仅是图形的轮廓。填充使用了跟边线一样的颜色， 并且是最近传入setColor方法的颜色。要想绘制一个填充和边线颜色不同的图形，先设置一种颜色再调用填充方法，然后重新设置一种颜色再调用边线方法：
&&& image.setColor(Color.BLACK);&&& image.fillRect(5,10,40,20);&&& image.setColor(Color.RED);&&& image.drawRect(5,10,40,20);
　　绘制文本
　　你可以使用drawString方法在图像中插入文本。这个方法需要的参数：要插入的字符串， 第一个字符的基线坐标。 意思是：这个指定的点基本是文本写入区域的左下角，而p，q这样的是例外，它们的底部比那个点要低。
　　你可以用 setFont 方法设置字体，给它传入一个字体对象。想得到一个有具体大小的字体对象，最简便的方法是使用 deriveFont 方法复制一个字体对象。你可以用 getFont 方法获得当前图像正在使用的字体。要在变量里存储字体对象，我们需要先在Java文件的顶部添加 import 语句来告诉计算机从哪找到这个字体对象：
import java.awt.F
　　以下代码 （来自气球脚本的 ScoreBoard 类）可以在之后用来得到一个大小48的字体对象：
&&& Font font = image.getFont();&&& font = font.deriveFont(48);&&& image.setFont(font);
　　那个字体之后就可以被 drawString 调用：
image.drawString(title, 60, 101);
　　要想获得某一风格的字体，如 serif/sans-serif 或 bold/italic/underlined，请查看 Font 类的构造方法―the Java Library Documentation for the Font class.
　　在Greenfoot全球站点有一系列关于这方面的实用 视频教程 .
　　复制图像到另一个图像
　　GreenfootImage 提供一个方法把一个图像写入另一个图像。如果你想在角色图像里添加一个图标，以表现这个角色一些不同的情况，比如它正在搬东西。你就可以使用这个方法。想把一个图像写入另一个图像是很容易的，通过调用这个图像对象中的 drawImage 方法来实现，传入要复制的图像和要放置的坐标。
image.drawImage(new GreenfootImage("smaller-image.png"), 10, 10);
　　缩放，镜像 & 旋转
　　图像可以缩放 （拉伸或压缩）， 垂直或水平镜像，和旋转。
　　scale method 需要两个整数作为参数，他们表示你需要的宽和高。然后这个图像就会被拉伸 （缩小）到那个尺寸。
　　要得到镜像，可以使用 mirrorVertically 或 mirrorHorizontally 方法中的一个。他们不需要参数，并沿着恰当的中心线翻转图像。
　　可以使用 rotate 方法旋转图像，它需要角度数值来旋转图像。注意：如果你的参数不是90度的倍数，那么图像边角的部分就会被切掉，而图片仍然会有水平和垂直边缘。
　　如果这张图片被用作角色图像，那么使用 Actor 对象的 setRotation 方法产生的转动通常是更完美的，因为它是在一个不同的角度合理显示图像， 而不是改变图像。另外，Actor 的 setRotation 方法可以记忆自身的旋转，这可以用来定义对象的移动方向，而 GreenfootImage 对象的 rotate 方法只能用指定的角度值旋转图像，而不会改变角度。
　　透明度
　　图像可以使用 setTransparancy 方法调整部分透明度。它可以使你看见图像之下的其他对象和背景。这个方法需要一个参数，取值范围在0-255之间。0表示完全透明，255表示完全不透明。
　　使用较低的数值用户将会看不见图像；在有背景图案的情况下把透明度调整到40左右，看清图像是比较困难的。然而，角色仍然会被碰撞探测方法发现。如果有一个角色，能够与之产生碰撞， 用户希望避开它，并且它使用了透明度进行消褪，那么在它的透明度降到0之前将它从这个世界移除是一个好的主意。
　　处理单个像素
　　你可以使用 setColorAt 方法为每个独立的像素设置颜色，将这个点的（x，y）坐标和颜色传入方法来进行设置。
　　蚂蚁脚本的 'Food' 类使用了这个方法。它通过循环生成堆里的每块食物，并且在图像上的随机位置为每个块食物画四个相邻的像素点。每块食物像素的颜色被搭配出了3D效果。
&&&&&&& GreenfootImage image = new GreenfootImage(SIZE, SIZE);&&&&&&& for (int i = 0; i & i++) {&&&&&&&&&&& int x = randomCoord();&&&&&&&&&&& int y = randomCoord();&&&&&&&&&&& image.setColorAt(x, y, color1);&&&&&&&&&&& image.setColorAt(x + 1, y, color2);&&&&&&&&&&& image.setColorAt(x, y + 1, color2);&&&&&&&&&&& image.setColorAt(x + 1, y + 1, color3);&&&&&&& }&&&&&&& setImage(image);
　　9、探测其它物体 （交互）
　　Greenfoot API 很奇妙的一个特性是在世界中发现其它对象的机制。当你想让对象间相互交流，你需要能 "看见" 这些对象。Greenfoot 给你提供了很多方法来发现其它对象，以适合不同脚本的需求。我们将这种方法分成了两种不同的类别：一种完全基于对象的位置，一种正使用的对象的图像表示。当创建了 Actor 的子类，这里讨论的方法都可以使用。
　　基于单元
　　在一些脚本中，像袋熊，对象完全被包含在单元格中，并且你仅仅对对象单元格的位置感兴趣。对于这些脚本，我们有完全运行在对象位置上的方法。我们把这些方法称为基于单元。
　　袋熊寻找树叶来吃的时候，它们会看看当前位置是否有树叶。袋熊 foundLeaf（） 方法中实现这种功能的代码是：
Actor leaf = getOneObjectAtOffset(0, 0, Leaf.class);
　　这个方法返回一个当前袋熊相对位置的对象。前两个参数指定当前位置的偏移量，这个例子中是 （0，0），它们只能吃当前网格的树叶。 第三个参数指定我们要寻找的对象的类型。这个方法仅仅返回给定类或子类的对象。如果这个位置不止一个对象，它就不能确定该返回哪一个。
　　如果你有一个特能吃的袋熊，你可以用另一个方法返回一列树叶：
List leaves = getObjectsAtOffset(0, 0, Leaf.class);
　　List leaves = getObjectsAtOffset（0， 0， Leaf.class）；在袋熊脚本执行的时候，袋熊是木讷的，并且没有使用任何真正袋熊的感官。如果我们想让袋熊在移动之前先环顾四周的树叶，我们有一些方法可供选择。
　　如果想让袋熊仅能看见东南西北四个相邻单元，我们可以使用下面的方法：
List leaves = getNeighbours(1, false, Leaf.class);
　　这个调用将会找到一步之内的相邻对象，对角的单元除外。如果你想包括对角的单元，你需要把false换成true.如果你想让袋熊看得更远，你可以把距离从1增加到更大。
　　下面我们制作了几张图片来说明为方法指定不同的参数来寻找邻居会涉及到哪些单元格。
　　不包含对角:getNeighbours(1, false, Leaf.class);
　　包含对角:getNeighbours(1, true, Leaf.class);
　　一个和 getNeighbours 方法功能上类似的方法：
List leaves = getObjectsInRange(2, Leaf.class);
　　调用这个方法将会返回两个单元格之内的所有所有对象（树叶类及其子类）。如果两个角色间的距离刚好相差2，那它就在范围之内。见图解：
　　getObjectsInRange(2, Leaf.class);
　　基于图画
　　有时候用单元格的位置来确定交互不够精确。Greenfoot 有几个方法可以用来检测角色的图像是否部分重叠。
　　Actor leaf = getOneIntersectingObject(Leaf.class);　　List leaves = getIntersectingObjects(Leaf.class);
　　但要知道，这些方法比起基于单元的方法，需要更大的计算量，如果它生成了很多角色，可能会降低你程序的执行速度。
　　10、键盘控制
　　有两种方法在 Greenfoot 脚本中使用键盘：按住键盘执行连续动作，或者敲击键盘执行独立动作。
　　键盘上的键，当它们传入方法或从方法返回时，使用的是他们的名字。可接受的名字有：
　　●& "a"， "b"， ……， "z" （字母）， "0"……"9" （数字）， 更多标点符号……
　　●& "up"， "down"， "left"， "right" （光标键）
　　●& "enter"， "space"， "tab"， "escape"， "backspace"
　　●& "F1"， "F2"， ……， "F12" （功能键）
　　连续动作： 长按一个键
　　lunarlander 示例脚本使用了这样的方法： 当按下 'down' 光标键，登录船的推进器点火。它使用了 the isKeyDown() method of the Greenfoot class 来实现。在一个角色的 act 方法中，调用这个方法，它用键名作为参数，如果当时按下那个键，它将返回 true.你可以在 if 语句中使用这个方法，使角色发生变化，只需要判断这个键是否被按下：
&&& if(Greenfoot.isKeyDown("down")) {&&&&&&& speed+=&&&&&&& setImage(rocketWithThrust);&&& } else {&&&&&&& setImage(rocket);&&& }
　　在这个方法中，应用字母键时，大写或小写字母可以作为这个方法的参数。
　　独立动作： 敲击一个键
　　Greenfoot 类的 getKey（） 方法调用之后，可以用来得到最近使用的键名。这个方法可以用作独立的动作，这个键必须是敲击而不是长按， 例如 'fire bullet' 动作：
&&& if(Greenfoot.getKey().equals("space")){&&&&&&& fireGun();&&& }
　　比较字符串不同于比较数字， 使用字符串的 equals 方法比用 == 运算符更好，因为字符串是对象 （和角色一样），而 == 运算符用作对象间的比较时，是判断它们是否为同一个对象，而不是比较它们的内容是否相同。
　　请注意，这个方法最后一次调用后，将返回最后一个按键，如果这个方法暂时没有调用，那么最近可能没有按键―如果没有键被点击。同样地，如果同时按下两个键，或在 getKey 两次调用间的间隔很短，那么只有最后一个会被返回。
　　11、鼠标控制
　　你可以用一些方法测试用户是否用鼠标进行了操作，这些方法在Greenfoot类中： mouseClicked， mouseDragged， mouseDragEnded， mouseMoved and mousePressed. 这些方法需要一个对象作为参数。通常它被用来判断鼠标是否操作了那个角色 （点击，拖动， 挪动， 等） .这个参数也可以是 world 对象，用来判断鼠标是否活动在一个没有角色的区域，或者是 null，用来判断鼠标是否操作了不需要的角色。
　　如果恰当的鼠标行为执行在指定的角色或世界里，那么方法就会返回true，否则返回 false.如果鼠标行为覆盖了很多角色，只有最上面的一个会返回 true.对于世界，如果鼠标行为没有发生在任何角色上，那这些方法只会返回true.
　　如果这个方法在 act 方法中调用，那么参数通常是那个角色对象，需要使用 this 关键字。例如，一个角色被点击时它可以使用下面的方法改变自己的形象。clickedImage 是一个包含GreenfootImage 对象的域，但是 this 不是一个变量，因此不需要声明。
&&& if(Greenfoot.mouseClicked(this)){&&&&&&& setImage(clickedImage);&&& }
　　mousePressed 方法用来判断鼠标键是否被按下，无论它是否已被释放。mouseClicked 用来判断鼠标按下后是否被释放。即，它判断鼠标是否被按下并且释放。mouseMoved 用来判断鼠标是否经过指定对象（没有按下）。mouseDragged 用来判断鼠标是否在按下的情况下经过对象。mouseDragEnded 用来判断鼠标拖动后是否被释放。
　　额外信息可以从 getMouseInfo 方法返回的 MouseInfo 对象中获得。使用这个对象，你可以找到鼠标操作的角色（如果真有）， 被点击的按钮 （也就是鼠标左右键），点击次数（单击或双击），以及鼠标的坐标。
　　这类信息用在了气球脚本中。mouseMoved 方法 （using null as the parameter as the move does not have to be over a specific actor） 和MouseInfo对象的 getX， getY 方法用来移动飞镖：
&&& if(Greenfoot.mouseMoved(null)) {&&&&&&& MouseInfo mouse = Greenfoot.getMouseInfo();&&&&&&& setLocation(mouse.getX(), mouse.getY());&&& }
　　mouseClicked 方法用来扎破气球。MouseInfo类的 getActor 方法没被用在这种情况，因为它总是要返回飞镖， 并且我们对于气球需要测试的点不是鼠标的位置，它在飞镖的尖端。
　　在Greenfoot全球站点上有关于处理鼠标输入的 视频教程 .
　　12、发出声音
　　在 Greenfoot 中播放音频是非常简单的。你需要做的只是将要播放的声音文件复制到你脚本的 sounds 文件中， 然后调用 Greenfoot 类的 playSound 方法，以要播放的音频文件名作为参数。
　　例如，lunarlander 播放了一个叫做 Explosion.wav 的声音文件，如果登录船冲撞到月球表面。这个文件在 lunarlander/sounds 文件夹中，并且被下面这行代码播放：
　　Greenfoot.playSound（"Explosion.wav"）；这些音频文件必须是 wav， aiff or au 文件。不支持Mp3文件，并且也不是所有的 wav 文件都能支持。如果一个 wav 文件不能播放，它需要转换成 "16位 PCM" wav 文件。很多音频程序都可以实现这种转换，例如优秀并且免费的 "Audacity" 有实现这种转换的输出功能。
　　声音文件名区分大小写 （也就是说 "sound.wav"， "Sound.wav" 以及 "sound.WAV" 都是不同的）；如果你使用了错误的拼写，你会得到一个 IllegalArgumentException 异常，同时这个声音不会播放。
　　13、控制脚本
　　Greenfoot 类提供了一些方法来控制脚本执行，而 World 类 提供了一些方法来控制脚本显示的外观，以及影响脚本的停止和开始。Greenfoot 允许你停止， 开始， 暂停 （推迟） 以及设定执行的速度（以及提供之前提到的 mouse， keyboard & sound 方法）。 World 类允许你设置角色出现在屏幕上的顺序，设置角色调用自己的 act 方法的顺序，以响应脚本的开始和停止。
　　停止脚本
　　Greenfoot.stop（） 方法使你可以停止脚本， 这通常在所有事情完成时调用。
&&& if(getY() == 0){&&&&&&& Greenfoot.stop();&&& }
　　调用 stop 相当于用户按下 Pause 按钮。之后用户可以点击 Act 或 Run 继续，但是在上面这个例子中，由于 if 语句的条件始终为 true，调用它后脚本就会停止，因此反复点击 Run 按钮没有效果。
　　设定速度
　　你可以用 Greenfoot.setSpeed（） 方法设定执行速度。在 World 的构造方法中设定合适的速度是一个好习惯。下面的语句设置速度为 50%：
Greenfoot.setSpeed(50);
　　Greenfoot.delay（） 使你可以将脚本推迟几步，步数由参数指定。注意，脚本被推迟的时间长度会呈现不同，这取决于代码的执行速度。
Greenfoot.delay(10); //Pause for 10 steps
　　Greenfoot.delay（10）； //Pause for 10 steps所有角色都会被推迟，当 delay 方法被调用的时候；如果你想让一些角色继续活动，或者想在这段时间里添加能继续活动的角色，那么使用布尔域或方法比较好，即当你使用delay时它是 false 而其余时间是 true.之后所有应该停止的角色都可以在他们 act 方法的开始检查：
&&& public void act(){&&&&&&& if(!isPaused()){&&&&&&&&&&& ...&&&&&&& }&&& }
　　启动脚本Greenfoot.start（） 方法用的地方比较少，和脚本里的大多数代码一样，只有在脚本启动后才能执行。不过，当脚本停止后用户可以从角色的弹出菜单中在世界里调用这些方法。在这种情况下，如果从弹出菜单中调用包含 Greenfoot.start（） 方法的方法将会确使脚本开始运行。
　　例如，在气球脚本中你可以启动脚本，出现气球，暂停脚本然后调用每个气球的 pop 方法。如果你添加下面的代码到 pop 方法，那么当用户试图扎破气球时，这个脚本将会通过弹出菜单重新执行。
&&& public void pop() &&& {&&&&&&& Greenfoot.start();&&&&&&& ...&&& }
　　设定角色的层叠顺序World类的 setPaintOrder 方法设定脚本层叠在屏幕上的顺序。层叠顺序由类指定：一个类的对象会总是出现在其它类对象的上面。不能指定同一个类对象的顺序。参数列表中第一个列出的对象会出现在之后列出的所有其它对象之上。没有明确指定的类的对象会从它们父类那里有效的继承层叠顺序。参数列表中没有列出的类的对象会出现在已列出类的对象的下面。
　　这个方法通常只在你的 World 子类的构造方法中调用。例如蚂蚁脚本：
setPaintOrder(Ant.class, Counter.class, Food.class, AntHill.class, Pheromone.class);
　　Ant 类的对象会一直出现在其它类角色之上（即，重叠时完全可见）。
　　想在角色类中调用这个方法，你先要得到当前世界的对象，使用 getWorld（） 方法：
getWorld().setPaintOrder(MyActor.class, MyOtherActor.class);
　　设定角色行为的顺序World类的 setActOrder 方法设定角色 act（） 方法调用的顺序。类似 setPaintOrder，行为顺序由类指定并且同类对象的顺序不能指定。当一些类没有在 setActOrder 方法的参数列表中指定，setPaintOrder的规则在这里同样适用。
　　每一轮 （比如点击一次 Act 按钮） ，act 方法会在每个对象中调用，根据setActOrder方法列表中的顺序依次执行。
　　响应脚本的开始和停止当脚本启动后，Greenfoot 会调用当前world对象的 started 方法，当脚本停止时它会调用 stopped 方法。如果你想在这些事件发生时运行一些代码，那就在 World 子类中覆盖这些方法。想在子类中 '覆盖' 一个方法，你只需要定义一个同名的方法，比如你怎样在每个你创建的子类中覆盖 Actor 类的 act 方法。
&&& public void started(){&&&&&&& // ... Do something when the scenario has started&&& }&&& &&& public void stopped(){&&& // ... Do something when the scenario has stopped&&& }
　　14、使用基础类
　　有很多可重用的类可以使用在你的项目中。它们可以帮助你实现脚本的功能和效果，而你自己编写需要花很长时间，或者你没有经验来实现。一些基础类本身就是角色，你可以直接用到你的脚本中 （比如 Explosion），一些是 Actor 的抽象子类，你需要为你自己的角色提供额外的功能 （比如 SmoothMover），而一些根本不是角色，但是能被角色公用（比如 Vector， 被 SmoothMover 使用）。
　　有一系列官方 Greenfoot 基础类在 . 也有一些收集的基础类 在 Greenfoot G要使用任意基础类，你先得下载它们的源代码。在这一系列官方实用类中，单击类的名字会向你显示它的源代码。你也可以右击这个链接保存 .java 源文件。在 gallery，单击一个脚本转到它的页面。在那里你可以试用这个脚本，或单击它上面的 Download the source for this scenario 链接。
　　有两种方法可以将一个基础类复制到你的脚本中。最简单的是在你个脚本中创建一个同名的类，然后复制这个基础类的所有代码并粘贴到你刚创建的类中。另一种方法是将那个类的文件保存到你的脚本文件夹中。如果你正使用一个来自官方的基础类，那么将 .java 保存到你的脚本文件夹中。如果你正使用一个来自 gallery 脚本的类，从gallery脚本文件夹复制这个文件（同名并且带。java扩展名）到你脚本的文件夹。（你也可以同样地复制。class和。ctxt文件，但是没必要）
　　注意， 一些基础类使用了其它基础类，以及图像或者声音，因此你必须把它们都复制到你的脚本中才能使用它们。（例如，SmoothMover abstract actor 需要 Vector 基础类， 而 Explosion actor 需要一张图片和一个声音文件在各自的 images 和 sounds 文件夹中）
　　使用可重用的角色
　　一旦你将一个可以再度使用的角色复制到你的类中，那它就可以像你脚本中任何其它角色一样使用―你可以创建它的实例或子类，设置它的图像和编辑它的代码。
　　使用抽象角色
　　一些基础类是抽象的。意思是你不能创建它们的实例―你不能直接将它们放入世界―类似于 Actor 类自身的原理。 要使用它们，创建抽象类的子类的角色―可以从弹出菜单中选择 New subclass，或者在角色源代码中改变 extends 关键字后的抽象类。例如，使一个叫做 MyActor 的现有的就角色成为 SmoothMover 类的子类，在 MyActor 类的源代码中改变适当的语句，from：
　　class MyActor extends Actor
　　to:　　class MyActor extends SmoothMover
　　使用公用类
　　要使用既不是角色也不是抽象角色的基础类，你可以用和其它基础类一样的方法将他们复制到你的脚本中。因为它们不是角色，所以你不能把它们放入世界―它们是用来被角色的源代码使用的。例如，Vector 基础类用来存储运动矢量（具有方向和速度），它被 SmoothMover 类用来存储它的运动。这些类可以被创建，并存放在变量里，并且像其它对象一样拥有自己的可以调用的方法。
　　创建自己的基础类
　　如果你创建了一个类并希望与大家分享，创建一个脚本说明这个类并上传到 Greenfoot Gallery ，附带 演示 标签，并确认包含了源代码。 gallery 的其他用户就可以查看，测试，留下反馈信息以及下载它供他们使用，之后它可能会被添加进 Support classes 收藏。
　　15、导出脚本
　　Greenfoot 给你提供了3种方法导出脚本，它们在Scenario菜单下的 Export…… 选项。这个3个选项是：
　　●& Publish the scenario to the Greenfoot gallery（把脚本公布到Greenfoot gallery）
　　●& Export the scenario as a webpage（导出网页）
　　●& Export the scenario as an application（导出应用程序）
　　把脚本公布到 Greenfoot gallery
　　Greenfoot gallery 的网址是
它为 Greenfoot 用户提供了一条和其他人 分享脚本的途径，测试其他人的脚本，留下或收到反馈信息。
　　把你的脚本发布到 greenfoot gallery，使浏览这个站点的人公开地看到它。如果你仅仅希望吧你的脚本分享给特定的人，那就导出应用程序并使用电子邮件发布。
　　要把脚本发布到 gallery，你需要一个 gallery 账户。你可以创建一个账户，通过后面的 gallery 主页的连接或者点击导出窗口底部的 Create account 链接。一旦你创建了一个账户，以后每次你想公布脚本的时候，只需在导出窗口中输入你的用户名和密码。
　　导出窗口的 Publish 页面给你提供了填写脚本发布信息的区域。
　　Gallery 上每个脚本都有一个图标，通常是脚本部分截图。你可以你可以选择显示在 Scenario icon 框里的图标。它显示了脚本当前的画面。你可以使用方框旁边的滑块放大或缩小画面，还可以在框里拖动画面（放大之后）来选择你想要的区域。如果你运行了脚本，并且中途暂停，那么你的图标就可以显示脚本运行的画面。 如果在脚本启动的时候你的主要角色还没出现，它就非常有用。
　　为你的脚本键入一个名字，以及简短的描述和详细的描述。简短的描述会出现在你的脚本列表的后面，比如在搜索结果页面。在gallery上，详细的描述会显示在你脚本的上面，并且可以包含注释和使用说明。如果你有自己的关于这个脚本的网页，你可以在gallery上键入 URL 提供一个链接。
　　Greenfoot gallery 用标签分类管理脚本。选择一些和你脚本有关的常用标签，以及你自己的任意标签。标签通常只有一个单词，或是用连字符衔接的少量单词， 并且在文本框中，一行只能写一个标签。查看gallery主页上的标签集，你会知道用什么标签比较合适。使用其他作者使用过的标签通常是一个好主意，以便同类脚本能被放到一起。导出窗口中给你提供了常用的标签：
　　游戏类
　　Greenfoot特性介绍或新方法的演示
　　simulation
　　现实世界的模型，比如蜂群的行为或机器的运转
　　用鼠标输入的脚本
　　使用了某种图形用户界面的脚本 （比如按钮， 对话框， 滑块和其它应用类输入）
　　你可以为你的脚本选择两个额外的选项。如果你勾选了 the Publish source code 复选框，gallery上的其它用户将可以下载你的脚本来查看源代码，也能在他们的电脑上使用（不过这并不影响它在 gallery 上的版本）。如果你选择了这一项，你的脚本在发布的时候会附加上 with-source标签。
　　Lock scenario 选项使你可以防止用户在脚本运行前改变执行速度和拖动对象。如果你不勾选此框，那么用户就可以移动你的角色和改变速度，就像它在 Greenfoot 里一样。
　　一旦当你填完了所有资料，确认你键入了用户名和密码然后，点击 Export 按钮就可以将你的脚本发布到gallery.如果你点击 Close，那么你键入的资料将会被保存，以供你想导出时备用。
　　导出网页
　　想把你的脚本导出为网页，选择导出窗口的 Webpage 面板。选择一个文件夹来保存网页，选择你你是否想锁定脚本，然后点击 Export.
　　勾选 Lock scenario 复选框防止用户在脚本运行前改变执行速度和拖动对象。如果你不勾选此框，那么用户就可以移动你的角色和改变速度，就像它在 Greenfoot 里一样。
　　注意，以网页形式导出脚本不会将它发布到网上。它仅仅使你可以再网页浏览器中查看你的脚本。想把脚本发布到网上（如果你没有自己的站点）需要使用导出窗口的 Publish 面板将它发布到 Greenfoot gallery.想把脚本发布到自己的站点上，以网页形式导出然后将l 和 .jar 文件上传到你的web服务器上。
　　导出应用程序
　　想把你的脚本导出为应用程序，选择导出窗口的 Application 面板。选择一个文件夹来保存网页，选择你你是否想锁定脚本，然后点击 Export.
　　勾选 Lock scenario 复选框防止用户在脚本运行前改变执行速度和拖动对象。如果你不勾选此框，那么用户就可以移动你的角色和改变速度，就像它在 Greenfoot 里一样。
　　这个导出的应用程序是一个可执行的 jar 文件。任何安装了正确Java版本的电脑都可以运行这个程序。大多数电脑上你可以双击 jar 文件来运行。如果电脑没有设置像那样运行 jar 文件，你只有在命令行中使用下面的命令来运行脚本：
　　java -jar Scenario.jar
　　当你在DOS下进入了 jar 所在文件夹，把 Scenario.jar 改成你自己的文件名。
H3C认证Java认证Oracle认证
基础英语软考英语项目管理英语职场英语
.NETPowerBuilderWeb开发游戏开发Perl
二级模拟试题一级模拟试题一级考试经验四级考试资料
软件测试软件外包系统分析与建模敏捷开发
法律法规历年试题软考英语网络管理员系统架构设计师信息系统监理师
高级通信工程师考试大纲设备环境综合能力
路由技术网络存储无线网络网络设备
CPMP考试prince2认证项目范围管理项目配置管理项目管理案例项目经理项目干系人管理
职称考试题目
招生信息考研政治
网络安全安全设置工具使用手机安全
生物识别传感器物联网传输层物联网前沿技术物联网案例分析
Java核心技术J2ME教程
Linux系统管理Linux编程Linux安全AIX教程
Windows系统管理Windows教程Windows网络管理Windows故障
数据库开发Sybase数据库Informix数据库
&&&&&&&&&&&&&&&
希赛网 版权所有 & &&