### Chapter 2 - The First Program: Little Crab

```Chapter 6 - Interacting Objects:
Newton’s Lab
Bruce Chittenden
6.1 The Starting Point: Newton’s Lab
Exercise 6.1
Right Click on space
Exercise 6.2
Sun and Planet
Exercise 6.2
Sun and Two Planets
Exercise 6.2
Sun, Planet, and Moon
Exercise 6.3
Exercise 6.4
Exercise 6.5 Space Class
import greenfoot.*; // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
import java.awt.Color;
/**
* Space. The final frontier.
*
* @author Michael Kolling
* @version 1.0
*/
public class Space extends World
{
Exercise 6.5 Space Constructor
/**
* Create space.
*/
public Space()
{
super(960, 620, 1);
// Uncomment one of the following method calls
// if you want the objects created automatically:
//sunAndPlanet();
//sunAndTwoPlanets();
//sunPlanetMoon();
}
Exercise 6.5 SunAndPlanet ()
/**
* Set up the universe with a sun and a planet.
*/
public void sunAndPlanet()
{
removeAllObjects();
addObject (new Body (50, 240.0, new Vector(270, 0.03), new Color(255, 216, 0)), 460, 270);
addObject (new Body (20, 4.2, new Vector(90, 2.2), new Color(0, 124, 196)), 695, 260);
}
Exercise 6.5 sunAndTwoPlanets ()
/**
* Set up the universe with a sun and two planets.
*/
public void sunAndTwoPlanets()
{
removeAllObjects();
addObject (new Body (50, 240.0, new Vector(270, 0.0), new Color(255, 216, 0)), 460, 310);
addObject (new Body (20, 4.2, new Vector(90, 2.2), new Color(0, 124, 196)), 695, 300);
addObject (new Body (24, 4.6, new Vector(270, 1.8), new Color(248, 160, 86)), 180, 290);
}
Exercise 6.5 sunPlanetMoon ()
/**
* Set up the universe with a sun, a planet, and a moon.
*/
public void sunPlanetMoon()
{
removeAllObjects();
addObject (new Body (50, 240.0, new Vector(270, 0.0), new Color(255, 216, 0)), 460, 270);
addObject (new Body (20, 4.2, new Vector(90, 2.2), new Color(0, 124, 196)), 720, 260);
addObject (new Body (5, 0.8, new Vector(90, 3.25), new Color(240, 220, 96)), 748, 260);
}
Exercise 6.5 removeAllObjects ()
/**
* Remove all objects currently in the world.
*/
private void removeAllObjects()
{
removeObjects (getObjects(Actor.class));
}
6.2 Helper Classes:
SmoothMover and Vector
http://www.greenfoot.org/programming/classes.html
Some Helper Classes
•Counter
•Explosion
•Mover
•Plotter
•Rotator
•Slider
•Vector
•Wander
SmoothMover
SmoothMover can, for example, have the x-coordinate
12.3. If we now move this actor along the x-coordinate
in increments of 0.6, its successive locations will be
12.3, 12.9, 13.5, 14.1, 14.7, 15.3, 15.9, 16.5, 17.1, . . .
and so on. We will see the actor on screen at rounded
x-coordinates.
12,
13, 14, 14,
15, 15, 16,
17, 17, . . .
Abstract Classes
public abstract class SmoothMover extends Actor
{
private Vector movement;
private double exactX; Cannot Create Objects for
private double exactY;
This Class, No Constructor
public SmoothMover()
{
this(new Vector());
}
/**
* Create new thing initialised with given speed.
*/
public SmoothMover(Vector movement)
{
this.movement = movement;
}
Exercise 6.6
accelerate
getExactX
getExactY
getMovement
getSpeed
move
setLocation
setLocation
Exercise 6.7
/**
* Set the location using exact (double) co-ordinates.
*/
public void setLocation(double x, double y)
{
exactX = x;
exactY = y;
super.setLocation((int) x, (int) y);
}
Can have the same name,
as long as their parameters
are different. This means
that the methods (or
constructors) have different
signatures.
/**
* Set the location of this actor. Redefinition of the standard Greenfoot
* method to make sure the exact co-ordinates are updated in sync.
*/
public void setLocation(int x, int y)
{
exactX = x;
exactY = y;
super.setLocation(x, y);
}
It is perfectly legal to have two methods that have
the same name, as long as their parameter lists
name of the method is Overloaded - it refers to
more than one method.)
Vectors
dy
dx
Polar Representation = length and direction
Cartesian Representation = dx and dy
Exercise 6.8
Exercise 6.8
Exercise 6.9
Which methods can be called thru
Which methods cannot?
Exercise 6.9
public abstract class SmoothMover extends Actor
{
private Vector movement;
private double exactX;
private double exactY;
smoothMover is not Callable since it
is declared as an Abstract Class
public SmoothMover()
{
this(new Vector());
}
/**
* Create new thing initialised with given speed.
*/
public SmoothMover(Vector movement)
{
this.movement = movement;
}
Exercise 6.10
/**
* Construct a Body with default size, mass, movement and color.
*/
public Body()
{
Body Class has Two Constructors
this (20, 300, new Vector(0, 1.0), defaultColor);
This is Another Example of
}
/**
* Construct a Body with a specified size, mass, movement and color.
*/
public Body(int size, double mass, Vector movement, Color color)
{
this.mass = mass;
GreenfootImage image = new GreenfootImage (size, size);
image.setColor (color);
image.fillOval (0, 0, size-1, size-1);
setImage (image);
}
6.3 The Existing Body Class
A constructor without any parameters is also called
a Default Constructor
The Body class has two constructors. One
constructor has no parameters and the other
constructor has four parameters. The default
constructor makes it easy for us to create bodies
interactively without having to specify all the
details.
Code 6.1
public class Body extends SmoothMover
{
/**
* Construct a Body with default size, mass, movement and color.
*/
public Body()
{
this (20, 300, new Vector(0, 1.0), defaultColor);
}
/**
* Construct a Body with a specified size, mass, movement and color.
*/
public Body(int size, double mass, Vector movement, Color color)
{
this.mass = mass;
GreenfootImage image = new GreenfootImage (size, size);
image.setColor (color);
image.fillOval (0, 0, size-1, size-1);
setImage (image);
}
this
this (20, 300, new Vector (90, 1.0), defaultColor );
This line looks almost like a method call, except it uses
the keyword this instead of a method name. Using this
the constructor executes the other constructor, the one
with parameters.
this.mass = mass;
When we write this.mass, we specify that we mean the
mass field of the current object.
Exercise 6.11
/**
* Construct a Body with default size, mass, movement and color.
*/
public Body()
Remove the “this”
{
this (20, 300, new Vector(0, 1.0), defaultColor);
}
/**
* Construct a Body with a specified size, mass, movement and color.
*/
public Body(int size, double mass, Vector movement, Color color)
{
this.mass = mass;
GreenfootImage image = new GreenfootImage (size, size);
image.setColor (color);
image.fillOval (0, 0, size-1, size-1);
setImage (image);
}
Exercise 6.11
Does is Compile?
Does it Execute?
What does the Code do?
What is its effect?
Code 6.2
private static final double GRAVITY = 5.8;
private static final Color defaultColor = new Color(255, 216, 0);
The term final defines this field to be a constant. A
constant has similarities to a field, in that we can use
the name in our code to refer to its value, but the
value can never change (it is constant).
The effect of the static keyword is that this constant
is shared between all actors of this class.
6.4 First Extension: Creating Movement
The first obvious experiment
is to make bodies move.
SmootherMover Class has a
move () method and since
Body is a SmoothMover, it too
Exercise 6.12
/**
* Act. That is: apply the gravitation forces from
* all other bodies around, and then move.
*/
public void act()
{
move();
}
Add the move () Method to the act ()
Method of the Body Class.”
Exercise 6.12
The Default Speed
is 1.0
The Default Direction
is 0 Degrees
Exercise 6.13
Multiple Objects Move from
Left to Right at a Constant
Speed
Exercies 6.14
The Sun Does Not Appear to Move
The Earth Moves Straight Down Rapidly
Exercise 6.14
Exercise 6.14
Exercise 6.15
/**
* Construct a Body with default size, mass, movement and color.
*/
public Body()
{
this (20, 300, new Vector(-180, 1.0), defaultColor);
}
Change the Direction in the Default
Constructor from 0 to -180
Exercise 6.15
-90
270
-180
180
0
360
-270
90
6.5 Using Java Library Classes
import java.awt.Color;
java.awt Package
Color Class
new Color (248, 160, 86)
R G B
java.awt.Color
Exercise 6.16
Exercise 6.17
We can give an outline of the task in
pseudo-code.
apply forces from other bodies:
get all other bodies in space;
for each of those bodies:
{
apply gravity from that body to our own;
}
Code 6.3
/**
* Act. That is: apply the gravitation forces from
* all other bodies around, and then move.
*/
public void act()
{
move ();
}
Code 6.4
/*
* Act. For a body, that is: apply all the gravitation forces from
* all other bodies around, and then move.
*/
public void act()
{
applyForces ();
move ();
}
/*
* Apply the forces of gravity from all other celestial bodies in this universe
*/
private void applyForces()
{
// work to do here
}
Private Methods
Methods can be public or private. When
methods are intended to be called from outside
the class (either interactively by a user or from
another class), the they must be public. When
methods are intended to be called only from
other methods within the same class, then they
should be declared private.
Exercise 6.18
Exercise 6.18
getObjects ( java.lang.Class cls )
getObjectsAt ( int x, int y, java.lang.Class cls )
numberOfObjects ( )
removeObject ( Actor object)
removeObjects ( java.util.Collection objects )
getObjects ()
java.util.List getObjects ( java.lang.Class cls )
Gives a list of all objects in the world of a
particular class
getObjects ( Body.class )
Gets a list of all the objects in the world of
class Body
getObjects ( null )
The keyword null is a special expression that
means nothing, or no object
getWorld().getObjects
World getWorld()
There is a method in the Actor class that gives
World getWorld ().
getWorld().getObjects ( Body.class )
getObjects is a method of the World class, so
it must be called on a World object. We will
write our code in the Body class, so we must
first obtain the World object to call this
method on.
6.7 The List Type
java.util.List
The List type is not a class, but an interface.
Interfaces are a Java construct that provides an
abstraction over different possible
implementing classes.
Exercise 6.19
Exercise 6.19
add ( int index, E element )
addAll ( Collection <? extends E> c )
addAll ( int index, Collection< ? extends E> c )
remove ( int index )
remove ( Object o )
size ()
Exercise 6.20
Interface List<E>
Interface List<E>
Interface List<E>
Interface is in the place of class and the
notation <E> is after the type name. This is
the Generic Type. This means that the type
List needs an additional type specified as a
parameter. This second type specifies the
type of the elements held within the list.
Interface List<E>
List<String>
A list of Strings
List<Actor>
A list of Actors
List<Body> bodies
A list of bodies
List<Body> bodies = getWorld().getobjects (Body.class):
The variable bodies holds a list of all the
bodies that exist in the World.
Code 6.5
import java.util.List;
/*
* Apply the forces of gravity from all other celestial bodies in this universe
*/
private void applyForces()
{
List<Body> bodies = getWorld().getObjects(Body.class);
}
6.8 The for-each Loop
Java has a specialized loop for stepping through every
element of a collection. It is called a for-each loop .
for ( Element Type variable : collection )
{
statements;
}
The for-each Loop
for ( Body body : bodies )
{
body.move();
}
for each body in bodies do:
body = first element from ‘bodies’;
execute loop statements;
body = second element for ‘bodies’;
execute loop statements;
body = third element from ‘bodies’;
execute loop statements;
. . .
Code 6.6
/*
* Apply the forces of gravity from all other celestial bodies in this universe
*/
private void applyForces()
{
List<Body> bodies = getWorld().getObjects(Body.class);
for (Body body : bodies)
{
if (body != this)
{
applyGravity (body);
}
}
}
/*
* Apply the gravity force of a given body to this one.
*/
private void applyGravity (Body other)
{
// work to do here
}
6.9 Applying Gravity
Newton's Law of Universal Gravitation
states that every massive particle in the universe attracts
every other massive particle with a force which is directly
proportional to the product of their masses and inversely
proportional to the square of the distance between them.
Code 6.7
/*
* Apply the gravity force of a given body to this one.
*/
private void applyGravity(Body other)
{
double dx = other.getExactX() - this.getExactX();
double dy = other.getExactY() - this.getExactY();
Vector force = new Vector (dx, dy);
double distance = Math.sqrt (dx*dx + dy*dy);
double strength = GRAVITY * this.mass * other.mass / (distance * distance);
double acceleration = strength / this.mass;
force.setLength (acceleration);
}
Pythagorean Theorem
2
a
+
2
b
=
2
c
Exercise 6.21
Math Class sqrt
Exercise 6.22
max ( int a, int b )
Exercise 6.22
Acceleration
acceleration =
force
mass
Once we have calculated the acceleration, we
can set our force vector to the correct length
and add this vector to the movement of our
body.
Exercise 6.23
a2 + b2 = c2
dx2 + dy2 = distance2
(other.getExactX()-this.getExactX())2 + (other.getExactY()-this.getExactY())2 = distance2
distance = Math.sqrt ( (other.getExactX()-this.getExactX())2 + (other.getExactY()-this.getExactY())2 )
Exercise 6.23
mass1 X mass2
G
force =
distance
force = (mass1 * mass2 / distance2 ) * G
force = ( this.mass * other.mass / distance *distance ) * GRAVITY
Exercise 6.24
Exercise 6.24
Exercise 6.24
Exercise 6.25
If the Gravitational Constant
is set Higher than 5.8,
planets spiral into one
another, and if it is set
lower, planets fly off into
deep space.
Exercise 6.26
size mass
vector
movement
r
g
b
x
y
Exercise 6.26
addObject (new Body (100, 500.0, new Vector(270, 0.0), new Color(255, 216, 0)), 460, 270);
addObject (new Body (20, 4.2, new Vector(90, 2.2), new Color(0, 124, 196)), 720, 260);
addObject (new Body (5, 0.8, new Vector(90, 3.25), new Color(240, 220, 96)), 748, 260);
Exercise 6.27
All Systems That I Tested
Were Very Unstable
6.11 Gravity and Music
The idea to add sound to a gravity project was inspired by Kepler’s Orrery (see
https://keplers-orrery.dev.java.net/ )
Exercise 6.28
6.12 Summary of Programming
Techniques
One of the most important topics in the chapter
was the use of additional classes from the
Standard Java Class Library, Color, Math, and List.
Another new addition was the use of a new loop
the for-each loop. This loop is used to do
something to every element of a Java collection
such as a List. If we need an index, or a loop
independent of a collection, then we must use a
for loop or a while loop instead.
Concept Summary
```